WWWShop/wwwshop/controller/groupcontroller/groupcontroller.go

package groupcontroller

import (
	d "WWWShop/wwwshop/dao/database"
	u "WWWShop/wwwshop/dao/groupmanager"
    "WWWShop/wwwshop/model/group"
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
	"strings"
    "errors"
)

type GroupController struct{}

func New() GroupController {
	return GroupController{}
}

func (self GroupController) DELETE(w http.ResponseWriter, r *http.Request) {
    ids, groupnames, _, err := self.SetupInputForFilter(w, r)
    group_manager := u.New(d.DB())

    if err != nil {
        if err != nil {
            json_response,_ := EncodeJSONResponse(NewResponseError(err.Error()))
            fmt.Fprintf(w, json_response)
            return
        }
    }
    deleted_groups, err :=  group_manager.Delete(ids, groupnames)
    if err != nil {
        json_response, _ := EncodeJSONResponse(NewResponseError(err.Error()))
        fmt.Fprintf(w, json_response)
        return
    }
	deleted_groups_json, _ := EncodeJSONResponse(deleted_groups)
	fmt.Fprintf(w, deleted_groups_json)
}

func (self GroupController) SetupInputForFilter(w http.ResponseWriter, r *http.Request) ([]int64, []string, *int64, error) {
	query := r.URL.Query()
	groupnames, _ := query["groupname"]
	ids, _ := query["id"]
	pages, _ := query["page"]
	var page int64
	if len(pages) == 0 {
		page = 0
	} else {
        var err error
		page, err = strconv.ParseInt(pages[0], 0, 64)
        if err != nil {
			return nil, nil, nil, errors.New("Unable to parse int page.")
        }
	}
	ids_int := make([]int64, 0)
	for _, id := range ids {
		id_int, err := strconv.ParseInt(id, 0, 64)
		if err != nil {
			return nil, nil, nil, errors.New("Unable to parse int id.")
		}
		ids_int = append(ids_int, id_int)
	}
    return ids_int, groupnames, &page, nil
}

func (self GroupController) PUT(w http.ResponseWriter, r *http.Request) {
	var decoded_group_struct group.Group
	decoder := json.NewDecoder(r.Body)
	err := decoder.Decode(&decoded_group_struct)
    if err != nil {
        http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
        json_response, _ := EncodeJSONResponse(NewResponseError("Failed to decode json group on update."))
        fmt.Fprintf(w, json_response)
        return
    }
    if decoded_group_struct.Id == nil && decoded_group_struct.Groupname == nil {
        http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
        json_response, _ := EncodeJSONResponse(NewResponseError("Failed to get groupname or id needed to update groups."))
        fmt.Fprintf(w, json_response)
        return
    }
    if decoded_group_struct.Permissions == nil {
        decoded_group_struct.Permissions = make(map[string]string)
    }
    group_manager := u.New(d.DB())
    group, err := group_manager.Update(decoded_group_struct)
    if err != nil {
        http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        json_response, _ := EncodeJSONResponse(NewResponseError(strings.Join([]string{"Failed to update group with the given data, may be our fault: ", err.Error()}, "")))
        fmt.Fprintf(w, json_response)
        return
    }
    json_response, _ := EncodeJSONResponse(group)
    fmt.Fprintf(w, json_response)
}

func (self GroupController) GET(w http.ResponseWriter, r *http.Request) {
	group_manager := u.New(d.DB())
    ids, groupnames, page, err := self.SetupInputForFilter(w, r)
    if err != nil {
		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
        json_response, _ := EncodeJSONResponse(NewResponseError(err.Error()))
        fmt.Fprintf(w, json_response)
        return
    }
	groups, err := group_manager.Retrieve(*page, ids, groupnames)
	if err != nil {
		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
		json_response, _ := EncodeJSONResponse(NewResponseError(strings.Join([]string{"Unable to retrieve groups ", err.Error()}, "")))
		fmt.Fprintf(w, json_response)
		return
	}
	json_response, _ := EncodeJSONResponse(groups)
	fmt.Fprintf(w, json_response)
}

func (self GroupController) POST(w http.ResponseWriter, r *http.Request) {
	var decoded_group_struct POSTGroup
	decoder := json.NewDecoder(r.Body)
	err := decoder.Decode(&decoded_group_struct)
	if err != nil {
		json_response, _ := EncodeJSONResponse(NewResponseError("Unable to decode json"))
		fmt.Fprintf(w, json_response)
		return
	}
	if decoded_group_struct.Groupname == "" {
		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
		json_response, _ := EncodeJSONResponse(NewResponseError("Unable to get groupname"))
		fmt.Fprintf(w, json_response)
		return
	}
	if decoded_group_struct.Permissions == nil {
        decoded_group_struct.Permissions = make(map[string]string)
	}
	group_manager := u.New(d.DB())
	group, err := group_manager.Add(decoded_group_struct.Groupname, decoded_group_struct.Permissions)
	if err != nil {
		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
		json_response, _ := EncodeJSONResponse(NewResponseError(strings.Join(
			[]string{"Unable to create group ", err.Error()},
			"")))
		fmt.Fprintf(w, json_response)
		return
	}
	json_response, err := EncodeJSONResponse(group)
	fmt.Fprintf(w, json_response)
}

type Response interface{}

type ResponseError struct {
	Error string `json:"error"`
}

func NewResponseError(error_str string) ResponseError {
	return ResponseError{
		Error: error_str,
	}
}

type POSTGroup struct {
	Groupname          string `json:"groupname"`
	Permissions map[string]string `json:"permissions"`
}

func EncodeJSONResponse(response Response) (string, error) {
	var buffer bytes.Buffer
	encoder := json.NewEncoder(&buffer)
	err := encoder.Encode(response)
	if err != nil {
		return "", err
	}
	return buffer.String(), nil
}