WWWShop/wwwshop/controller/usercontroller/usercontroller.go

package usercontroller

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

type UserController struct{}

func New() UserController {
	return UserController{}
}

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

    if err != nil {
        if err != nil {
            json_response,_ := EncodeJSONResponse(NewResponseError(err.Error()))
            fmt.Fprintf(w, json_response)
            return
        }
    }
    deleted_users, err :=  user_manager.Delete(ids, usernames)
    if err != nil {
        json_response, _ := EncodeJSONResponse(NewResponseError(err.Error()))
        fmt.Fprintf(w, json_response)
        return
    }
	deleted_users_json, _ := EncodeJSONResponse(deleted_users)
	fmt.Fprintf(w, deleted_users_json)
}

func (self UserController) SetupInputForFilter(w http.ResponseWriter, r *http.Request) ([]int64, []string, *int64, error) {
	query := r.URL.Query()
	usernames, _ := query["username"]
	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, usernames, &page, nil
}

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

func (self UserController) POST(w http.ResponseWriter, r *http.Request) {
	var decoded_user_struct POSTUser
	decoder := json.NewDecoder(r.Body)
	err := decoder.Decode(&decoded_user_struct)
	if err != nil {
		json_response, _ := EncodeJSONResponse(NewResponseError("Unable to decode json"))
		fmt.Fprintf(w, json_response)
		return
	}
	if decoded_user_struct.Username == "" {
		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
		json_response, _ := EncodeJSONResponse(NewResponseError("Unable to get username"))
		fmt.Fprintf(w, json_response)
		return
	}
	if decoded_user_struct.PasswordPlaintext == "" {
		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
		json_response, _ := EncodeJSONResponse(NewResponseError("Unable to get password"))
		fmt.Fprintf(w, json_response)
		return
	}
	user_manager := u.New(d.DB())
	user, err := user_manager.AddWithPlainPassword(decoded_user_struct.Username, decoded_user_struct.PasswordPlaintext)
	if err != nil {
		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
		json_response, _ := EncodeJSONResponse(NewResponseError(strings.Join(
			[]string{"Unable to create user ", err.Error()},
			"")))
		fmt.Fprintf(w, json_response)
		return
	}
	json_response, err := EncodeJSONResponse(user)
	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 POSTUser struct {
	Username          string `json:"username"`
	PasswordPlaintext string `json:"password"`
}

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
}