1

internal/http/balance.go

@@ -0,0 +1,769 @@
+package http_router
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"log/slog"
+	"net/http"
+
+	"git-molva.ru/Molva/molva-backend/services/api_gateway/internal/constants"
+	rmodel "git-molva.ru/Molva/molva-backend/services/api_gateway/internal/request_model"
+	"github.com/gorilla/mux"
+)
+
+func (h *handler) getBalanceAgentHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "getBalanceAgentHandler"
+
+	var (
+		vars    = mux.Vars(r)
+		agentId = vars["agent_id"]
+	)
+
+	result, err := h.agentService.GetBalance(r.Context(), &rmodel.BalanceGetRequest{
+		OwnerId: agentId,
+	})
+	if err != nil {
+		h.handleAgentError(w, err)
+		h.logger.Error("error getting balance info",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) getTransactionListAgentHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "getTransactionListAgentHandler"
+
+	var (
+		vars    = mux.Vars(r)
+		agentId = vars["agent_id"]
+	)
+
+	request, err := new(rmodel.TransactionListGetRequest).FromQuery(r.URL.Query())
+	if err != nil {
+		http.Error(w, constants.ErrBadRequest.Error(), http.StatusBadRequest)
+		h.logger.Error("error parsing request: ",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName))
+
+		return
+	}
+
+	request.OwnerId = agentId
+
+	result, err := h.agentService.GetTransactionList(r.Context(), request)
+	if err != nil {
+		h.handleAgentError(w, err)
+		h.logger.Error("error getting transactions",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) createTransactionAgentHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "createTransactionAgentHandler"
+
+	var (
+		vars    = mux.Vars(r)
+		agentId = vars["agent_id"]
+	)
+
+	var request rmodel.TransactionCreateRequest
+	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+		http.Error(w, constants.ErrBadRequest.Error(), http.StatusBadRequest)
+		h.logger.Error("error while unmarshalling request: ",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName))
+
+		return
+	}
+
+	defer func(body io.ReadCloser) {
+		if err := body.Close(); err != nil {
+			http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+			h.logger.Error("error closing body",
+				slog.String("error", err.Error()),
+				slog.String("handler", handlerName))
+		}
+	}(r.Body)
+
+	request.OwnerId = agentId
+
+	result, err := h.agentService.CreateTransaction(r.Context(), &request)
+	if err != nil {
+		h.handleAgentError(w, err)
+		h.logger.Error("error creating transaction",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	// TODO: fix feed event
+	// go h.createTransactionFeedEvent(
+	// 	context.Background(),
+	// 	agentId,
+	// 	true,
+	// 	request.Amount,
+	// 	request.Currency,
+	// 	request.BankAccountId,
+	// 	handlerName,
+	// )
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) getBankAccountListAgentHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "getBankAccountListAgentHandler"
+
+	var (
+		vars    = mux.Vars(r)
+		agentId = vars["agent_id"]
+	)
+
+	result, err := h.agentService.GetBankAccountList(r.Context(), &rmodel.BankAccountListGetRequest{
+		OwnerId: agentId,
+	})
+	if err != nil {
+		h.handleAgentError(w, err)
+		h.logger.Error("error getting bank accounts",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) createBankAccountAgentHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "createBankAccountAgentHandler"
+
+	var (
+		vars    = mux.Vars(r)
+		agentId = vars["agent_id"]
+	)
+
+	var request rmodel.BankAccountCreateRequest
+	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+		http.Error(w, constants.ErrBadRequest.Error(), http.StatusBadRequest)
+		h.logger.Error("error while unmarshalling request: ",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName))
+
+		return
+	}
+
+	defer func(body io.ReadCloser) {
+		if err := body.Close(); err != nil {
+			http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+			h.logger.Error("error closing body",
+				slog.String("error", err.Error()),
+				slog.String("handler", handlerName))
+		}
+	}(r.Body)
+
+	request.OwnerId = agentId
+
+	result, err := h.agentService.CreateBankAccount(r.Context(), &request)
+	if err != nil {
+		h.handleAgentError(w, err)
+		h.logger.Error("error creating bank account",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	// FIXME: possible nil dereference
+	// h.createCreateBankAccountFeedEvent(r.Context(), agentId, true, resp, *request.BankName, handlerName)
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) updateBankAccountAgentHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "updateBankAccountAgentHandler"
+
+	var (
+		vars          = mux.Vars(r)
+		agentId       = vars["agent_id"]
+		bankAccountId = vars["bank_account_id"]
+	)
+
+	var request rmodel.BankAccountUpdateRequest
+	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+		http.Error(w, constants.ErrBadRequest.Error(), http.StatusBadRequest)
+		h.logger.Error("error while unmarshalling request: ",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName))
+
+		return
+	}
+
+	defer func(body io.ReadCloser) {
+		if err := body.Close(); err != nil {
+			http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+			h.logger.Error("error closing body",
+				slog.String("error", err.Error()),
+				slog.String("handler", handlerName))
+		}
+	}(r.Body)
+
+	request.Id = bankAccountId
+	request.OwnerId = agentId
+
+	if _, err := h.agentService.UpdateBankAccount(r.Context(), &request); err != nil {
+		h.handleAgentError(w, err)
+		h.logger.Error("error editing bank account",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	go h.createEditBankAccountFeedEvent(
+		context.Background(),
+		agentId,
+		true,
+		bankAccountId,
+		handlerName,
+	)
+
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// TODO: test when implemented
+func (h *handler) deleteBankAccountAgentHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "deleteBankAccountAgentHandler"
+
+	var (
+		vars          = mux.Vars(r)
+		agentId       = vars["agent_id"]
+		bankAccountId = vars["bank_account_id"]
+	)
+
+	result, err := h.agentService.DeleteBankAccount(r.Context(), &rmodel.BankAccountDeleteRequest{
+		Id:      bankAccountId,
+		OwnerId: agentId,
+	})
+	if err != nil {
+		h.handleAgentError(w, err)
+		h.logger.Error("error deleting bank account",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	go func() {
+		if err := h.feed.CancelEvent(context.Background(), bankAccountId, "Банковский счёт удален"); err != nil {
+			h.logger.Error("error cancelling event: ",
+				slog.String("error", err.Error()),
+				slog.String("handler", handlerName))
+		}
+	}()
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) getBalanceDistributorHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "getBalanceDistributorHandler"
+
+	var (
+		vars   = mux.Vars(r)
+		distId = vars["distributor_id"]
+	)
+
+	result, err := h.distributorService.GetBalance(r.Context(), &rmodel.BalanceGetRequest{
+		OwnerId: distId,
+	})
+	if err != nil {
+		h.handleDistributorError(w, err)
+		h.logger.Error("error getting balance",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) getCompanyBalanceDistributorHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "getCompanyBalanceDistributorHandler"
+
+	var (
+		vars      = mux.Vars(r)
+		companyId = vars["company_id"]
+	)
+
+	result, err := h.distributorService.GetBalance(r.Context(), &rmodel.BalanceGetRequest{
+		OwnerId: companyId,
+	})
+	if err != nil {
+		h.handleDistributorError(w, err)
+		h.logger.Error("error getting balance",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) getTransactionListDistributorHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "getTransactionListDistributorHandler"
+
+	var (
+		vars   = mux.Vars(r)
+		distId = vars["distributor_id"]
+	)
+
+	request, err := new(rmodel.TransactionListGetRequest).FromQuery(r.URL.Query())
+	if err != nil {
+		http.Error(w, constants.ErrBadRequest.Error(), http.StatusBadRequest)
+		h.logger.Error("error parsing request: ",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	request.OwnerId = distId
+
+	result, err := h.distributorService.GetTransactionList(r.Context(), request)
+	if err != nil {
+		h.handleDistributorError(w, err)
+		h.logger.Error("error getting transactions",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) getCompanyTransactionListDistributorHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "getCompanyTransactionListDistributorHandler"
+
+	var (
+		vars      = mux.Vars(r)
+		companyId = vars["company_id"]
+	)
+
+	request, err := new(rmodel.TransactionListGetRequest).FromQuery(r.URL.Query())
+	if err != nil {
+		http.Error(w, constants.ErrBadRequest.Error(), http.StatusBadRequest)
+		h.logger.Error("error parsing request: ",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	request.OwnerId = companyId
+
+	result, err := h.distributorService.GetTransactionList(r.Context(), request)
+	if err != nil {
+		h.handleDistributorError(w, err)
+		h.logger.Error("error getting transactions",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) createTransactionDistributorHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "createTransactionDistributorHandler"
+
+	var (
+		vars   = mux.Vars(r)
+		distId = vars["distributor_id"]
+	)
+
+	var request rmodel.TransactionCreateRequest
+	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+		http.Error(w, constants.ErrBadRequest.Error(), http.StatusBadRequest)
+		h.logger.Error("error while unmarshalling request: ",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName))
+
+		return
+	}
+
+	defer func(body io.ReadCloser) {
+		if err := body.Close(); err != nil {
+			http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+			h.logger.Error("error closing body",
+				slog.String("error", err.Error()),
+				slog.String("handler", handlerName))
+		}
+	}(r.Body)
+
+	request.OwnerId = distId
+
+	result, err := h.distributorService.CreateTransaction(r.Context(), &request)
+	if err != nil {
+		h.handleDistributorError(w, err)
+		h.logger.Error("error creating transaction",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	// TODO: fix feed event
+	// go h.createTransactionFeedEvent(
+	// 	context.Background(),
+	// 	distId,
+	// 	false,
+	// 	request.Amount,
+	// 	request.Currency,
+	// 	request.BankAccountId,
+	// 	handlerName,
+	// )
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) getBankAccountListDistributorHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "getBankAccountListDistributorHandler"
+
+	var (
+		vars   = mux.Vars(r)
+		distId = vars["distributor_id"]
+	)
+
+	result, err := h.distributorService.GetBankAccountList(r.Context(), &rmodel.BankAccountListGetRequest{
+		OwnerId: distId,
+	})
+	if err != nil {
+		h.handleDistributorError(w, err)
+		h.logger.Error("error getting bank accounts",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) getCompanyBankAccountListDistributorHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "getCompanyBankAccountListDistributorHandler"
+
+	var (
+		vars      = mux.Vars(r)
+		companyId = vars["company_id"]
+	)
+
+	result, err := h.distributorService.GetBankAccountList(r.Context(), &rmodel.BankAccountListGetRequest{
+		OwnerId: companyId,
+	})
+	if err != nil {
+		h.handleDistributorError(w, err)
+		h.logger.Error("error getting bank accounts",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) createBankAccountDistributorHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "createBankAccountDistributorHandler"
+
+	var (
+		vars      = mux.Vars(r)
+		companyId = vars["company_id"]
+	)
+
+	var request rmodel.BankAccountCreateRequest
+	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+		http.Error(w, constants.ErrBadRequest.Error(), http.StatusBadRequest)
+		h.logger.Error("error while unmarshalling request: ",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName))
+
+		return
+	}
+
+	defer func(body io.ReadCloser) {
+		if err := body.Close(); err != nil {
+			http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+			h.logger.Error("error closing body",
+				slog.String("error", err.Error()),
+				slog.String("handler", handlerName))
+		}
+	}(r.Body)
+
+	request.OwnerId = companyId
+
+	result, err := h.distributorService.CreateBankAccount(r.Context(), &request)
+	if err != nil {
+		h.handleDistributorError(w, err)
+		h.logger.Error("error creating bank account",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	// FIXME: possible nil dereference
+	// go h.createCreateBankAccountFeedEvent(
+	// 	context.Background(),
+	// 	distId,
+	// 	false,
+	// 	resp,
+	// 	*request.BankName,
+	// 	handlerName,
+	// )
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) updateBankAccountDistributorHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "updateBankAccountDistributorHandler"
+
+	var (
+		vars          = mux.Vars(r)
+		distId        = vars["distributor_id"]
+		bankAccountId = vars["bank_account_id"]
+	)
+
+	var request rmodel.BankAccountUpdateRequest
+	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+		http.Error(w, constants.ErrBadRequest.Error(), http.StatusBadRequest)
+		h.logger.Error("error while unmarshalling request: ",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName))
+
+		return
+	}
+
+	defer func(body io.ReadCloser) {
+		if err := body.Close(); err != nil {
+			http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+			h.logger.Error("error closing body",
+				slog.String("error", err.Error()),
+				slog.String("handler", handlerName))
+		}
+	}(r.Body)
+
+	request.OwnerId = distId
+	request.Id = bankAccountId
+
+	result, err := h.distributorService.UpdateBankAccount(r.Context(), &request)
+	if err != nil {
+		h.handleDistributorError(w, err)
+		h.logger.Error("error editing bank account",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	go h.createEditBankAccountFeedEvent(
+		context.Background(),
+		distId,
+		true,
+		bankAccountId,
+		handlerName,
+	)
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}
+
+func (h *handler) deleteBankAccountDistributorHandler(w http.ResponseWriter, r *http.Request) {
+	const handlerName = "deleteBankAccountDistributorHandler"
+
+	var (
+		vars          = mux.Vars(r)
+		distId        = vars["distributor_id"]
+		bankAccountId = vars["bank_account_id"]
+	)
+
+	result, err := h.distributorService.DeleteBankAccount(r.Context(), &rmodel.BankAccountDeleteRequest{
+		Id:      bankAccountId,
+		OwnerId: distId,
+	})
+	if err != nil {
+		h.handleDistributorError(w, err)
+		h.logger.Error("error deleting bank account",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+
+		return
+	}
+
+	go func() {
+		if err := h.feed.CancelEvent(context.Background(), bankAccountId, "Банковский счёт удален"); err != nil {
+			http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+			h.logger.Error("error while cancelling event: ",
+				slog.String("error", err.Error()),
+				slog.String("handler", handlerName))
+		}
+	}()
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		http.Error(w, constants.ErrInternalServerError.Error(), http.StatusInternalServerError)
+		h.logger.Error("error encoding response",
+			slog.String("error", err.Error()),
+			slog.String("handler", handlerName),
+		)
+	}
+}