handlers

Documentation

Index

• Variables
• func WsPage(res http.ResponseWriter, req *http.Request)

Variables

var AddDeposit = func(w http.ResponseWriter, r *http.Request) {

	vars := mux.Vars(r)
	idClient := vars["idClient"]

	deposit := &models.Deposit{}
	err := json.NewDecoder(r.Body).Decode(deposit)
	if err != nil {
		u.Respond(w, u.Message(false, "Error while decoding request body"), 400)
		return
	}
	deposit.Clientidentificationcard = idClient
	resp := deposit.AddDepositClient()
	u.Respond(w, resp, 200)
}

AddDeposit to client

var Authenticate = func(w http.ResponseWriter, r *http.Request) {

	admin := &models.Admin{}
	err := json.NewDecoder(r.Body).Decode(admin)
	if err != nil {
		u.Respond(w, u.Message(false, "Invalid request"), 400)
		return
	}

	resp := models.Login(admin.Email, admin.Password)
	u.Respond(w, resp, 200)
}

Authenticate admin user

var AuthenticateClient = func(w http.ResponseWriter, r *http.Request) {

	client := &models.Client{}
	err := json.NewDecoder(r.Body).Decode(client)
	if err != nil {
		u.Respond(w, u.Message(false, "Invalid request"), 400)
		return
	}

	resp := models.LoginClient(client.Password, client.Seudonimo)
	u.Respond(w, resp, 200)
}

AuthenticateClient .

var CoinClient = func(w http.ResponseWriter, r *http.Request) {

	vars := mux.Vars(r)
	idClient := vars["idClient"]

	data := models.GetCoinsClient(idClient)
	resp := u.Message(true, "success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

CoinClient .

var CreateAdmin = func(w http.ResponseWriter, r *http.Request) {

	admin := &models.Admin{}
	err := json.NewDecoder(r.Body).Decode(admin)
	if err != nil {
		u.Respond(w, u.Message(false, "Invalid request"), 400)
		return
	}

	resp := admin.Create()
	u.Respond(w, resp, 201)
}

CreateAdmin user

var CreateClient = func(w http.ResponseWriter, r *http.Request) {

	client := &models.Client{}
	err := json.NewDecoder(r.Body).Decode(client)
	if err != nil {
		u.Respond(w, u.Message(false, "Invalid request"), 400)
		return
	}

	resp := client.CreateClient()
	u.Respond(w, resp, 201)
}

CreateClient .

var CreateEvent = func(w http.ResponseWriter, r *http.Request) {

	event := &models.Event{}
	err := json.NewDecoder(r.Body).Decode(event)
	if err != nil {
		u.Respond(w, u.Message(false, "Invalid request"), 400)
		return
	}

	resp := event.CreateEvent()
	u.Respond(w, resp, 201)
}

CreateEvent Event

var CreateHorse = func(w http.ResponseWriter, r *http.Request) {

	newsList := make([]models.Horse, 0)
	err := json.NewDecoder(r.Body).Decode(&newsList)
	if err != nil {
		u.Respond(w, u.Message(false, "Error while decoding request body"), 400)
		return
	}

	resp := models.CreateHorses(newsList)
	u.Respond(w, resp, 201)
}

CreateHorse add new Horses to db

var CreateRacing = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idEvent := vars["idEvent"]

	raceList := make([]models.Racing, 0)
	err := json.NewDecoder(r.Body).Decode(&raceList)
	if err != nil {
		u.Respond(w, u.Message(false, "Error while decoding request body"), 400)
		return
	}

	resp := models.CreateRaces(raceList, u.ConverStringToUint(idEvent))
	u.Respond(w, resp, 201)
}

CreateRacing .

var DeleteClient = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idClient := vars["idClient"]

	data := models.DeleteClient(&idClient)
	resp := u.Message(true, strconv.FormatBool(data))
	u.Respond(w, resp, 200)
}

DeleteClient client

var DeleteEvent = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idEvent := vars["idEvent"]

	data := models.DeleteEvent(u.ConverStringToUint(idEvent))
	resp := u.Message(true, strconv.FormatBool(data))
	u.Respond(w, resp, 200)
}

DeleteEvent Event

var DeleteHorse = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idRacing := vars["idRacing"]
	idHorse := vars["idHorse"]
	data := models.DeleteHorse(u.ConverStringToUint(idRacing), u.ConverStringToUint(idHorse))
	resp := u.Message(true, strconv.FormatBool(data))
	u.Respond(w, resp, 200)
}

DeleteHorse Delete Horse

var DeleteRacing = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idEvent := vars["idEvent"]
	idRacing := vars["idRacing"]

	data := models.DeleteRacing(u.ConverStringToUint(idEvent), u.ConverStringToUint(idRacing))
	resp := u.Message(true, strconv.FormatBool(data))
	u.Respond(w, resp, 200)
}

DeleteRacing .

var Dowithdrawal = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	clientIDCard := vars["clientidentificationcard"]

	retiro := &models.Retiro{}
	err := json.NewDecoder(r.Body).Decode(retiro)
	if err != nil {
		u.Respond(w, u.Message(false, "Error while decoding request body"), 400)
		return
	}

	resp := retiro.Dowithdrawal(clientIDCard)
	u.Respond(w, resp, 200)
}

Dowithdrawal from client coin

var GetAdminFor = func(w http.ResponseWriter, r *http.Request) {

	data := models.GetAdmins()
	resp := u.Message(true, "success")
	resp["data"] = data

	u.Respond(w, resp, 200)
}

GetAdminFor list admin user

var GetClientsFor = func(w http.ResponseWriter, r *http.Request) {

	data := models.GetClients()
	resp := u.Message(true, "success")
	resp["data"] = data

	u.Respond(w, resp, 200)
}

GetClientsFor list clients

var GetEventsFor = func(w http.ResponseWriter, r *http.Request) {

	data := models.GetEvents()
	resp := u.Message(true, "success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

GetEventsFor list Events

var GetHorses = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)

	data := models.GetHorses(vars["idRacing"])
	resp := u.Message(true, "success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

GetHorses list Horses

var GetRacingsFor = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idEvent := vars["idEvent"]

	data := models.GetRacings(u.ConverStringToUint(idEvent))
	resp := u.Message(true, "success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

GetRacingsFor .

var GetRematesFor = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idRacing := vars["idRacing"]

	data := models.GetRemates(u.ConverStringToUint(idRacing))
	resp := u.Message(true, "success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

GetRematesFor by racingID

var GetSpecificClient = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idClient := vars["idClient"]

	data := models.GetClient(&idClient)
	resp := u.Message(true, "success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

GetSpecificClient .

var GetSpecificEvent = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idEvent := vars["idEvent"]

	data := models.GetOneEvent(u.ConverStringToUint(idEvent))
	resp := u.Message(true, "success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

GetSpecificEvent find and show Event

var GetSpecificRacing = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idRacing := vars["idRacing"]

	data := models.GetRace(u.ConverStringToUint(idRacing))
	resp := u.Message(true, "Success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

GetSpecificRacing .

var GetSpecificRacingWithEvent = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idEvent := vars["idEvent"]
	idRacing := vars["idRacing"]

	data := models.FindRaceByEventID(u.ConverStringToUint(idEvent), u.ConverStringToUint(idRacing))
	resp := u.Message(true, "Success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

GetSpecificRacingWithEvent find and show Racing within event

var GetTablas = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idRacing := vars["idRacing"]

	data := models.GetTablas(u.ConverStringToUint(idRacing))
	resp := u.Message(true, "success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

GetTablas list

var HistorialDeposits = func(w http.ResponseWriter, r *http.Request) {

	vars := mux.Vars(r)
	idClient := vars["idClient"]

	data := models.GetAllDepositsClient(&idClient)
	resp := u.Message(true, "success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

HistorialDeposits client

var HistorialWithdrawal = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	clientIDCard := vars["clientidentificationcard"]

	data := models.GetAllWithdrawal(&clientIDCard)
	resp := u.Message(true, "success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

HistorialWithdrawal from client account

var RepartirGanancias = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idRacing := vars["idRacing"]
	idHorse := vars["idHorse"]

	data := models.RepartirGanancias(u.ConverStringToUint(idRacing), u.ConverStringToInt(idHorse))
	resp := u.Message(true, "Success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

RepartirGanancias .

var StateClient = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idClient := vars["idClient"]

	data := models.UpdateStateClient(&idClient)
	resp := u.Message(true, "Success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

StateClient .

var UpdateClient = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idClient := vars["idClient"]
	client := &models.Client{}

	err := json.NewDecoder(r.Body).Decode(client)
	if err != nil {
		u.Respond(w, u.Message(false, "Invalid request"), 400)
		return
	}

	data := client.UpdateClient(&idClient)
	resp := u.Message(true, "Success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

UpdateClient .

var UpdateEvent = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idEvent := vars["idEvent"]

	event := &models.Event{}
	err := json.NewDecoder(r.Body).Decode(event)
	if err != nil {
		u.Respond(w, u.Message(false, "Invalid request"), 400)
		return
	}

	data := event.UpdateEvent(u.ConverStringToUint(idEvent))
	resp := u.Message(true, "Success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

UpdateEvent find client

var UpdateHorse = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idRacing := vars["idRacing"]

	horse := &models.Horse{}
	err := json.NewDecoder(r.Body).Decode(horse)
	if err != nil {
		u.Respond(w, u.Message(false, "Invalid request"), 400)
		return
	}

	data := horse.UpdateHorse(u.ConverStringToUint(idRacing), vars["idHorse"])
	resp := u.Message(true, "Success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

UpdateHorse Horse data

var UpdateRacing = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idEvent := vars["idEvent"]

	raceList := make([]models.Racing, 0)
	err := json.NewDecoder(r.Body).Decode(&raceList)
	if err != nil {
		u.Respond(w, u.Message(false, "Error while decoding request body"), 400)
		return
	}

	data := models.UpdateRaces(raceList, u.ConverStringToUint(idEvent))
	resp := u.Message(true, "Success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

UpdateRacing .

var WithdrawHorseBefore = func(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idHorse := vars["idHorse"]
	idRacing := vars["idRacing"]

	data := models.WithdrawHorse(u.ConverStringToUint(idHorse), u.ConverStringToUint(idRacing))
	resp := u.Message(true, "success")
	resp["data"] = data
	u.Respond(w, resp, 200)
}

WithdrawHorseBefore Horse Before auction

Functions

func WsPage

func WsPage(res http.ResponseWriter, req *http.Request)

WsPage func