554 lines
19 KiB
Go
554 lines
19 KiB
Go
package handlers
|
|
|
|
import (
|
|
"log/slog"
|
|
"strconv"
|
|
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/services/branch"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/services/wallet"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/web_server/response"
|
|
customvalidator "github.com/SamuelTariku/FortuneBet-Backend/internal/web_server/validator"
|
|
"github.com/gofiber/fiber/v2"
|
|
)
|
|
|
|
type CreateBranchReq struct {
|
|
Name string `json:"name" example:"4-kilo Branch"`
|
|
Location string `json:"location" example:"Addis Ababa"`
|
|
BranchManagerID int64 `json:"branch_manager_id" example:"1"`
|
|
CompanyID int64 `json:"company_id" example:"1"`
|
|
IsSelfOwned bool `json:"is_self_owned" example:"false"`
|
|
}
|
|
|
|
type CreateSupportedOperationReq struct {
|
|
Name string `json:"name" example:"SportsBook"`
|
|
Description string `json:"description" example:"Betting on sport events"`
|
|
}
|
|
|
|
type SupportedOperationRes struct {
|
|
ID int64 `json:"id" example:"1"`
|
|
Name string `json:"name" example:"SportsBook"`
|
|
Description string `json:"description" example:"Betting on sport events"`
|
|
}
|
|
|
|
type CreateBranchOperationReq struct {
|
|
BranchID int64 `json:"branch_id" example:"1"`
|
|
OperationID int64 `json:"operation_id" example:"1"`
|
|
}
|
|
|
|
type BranchOperationRes struct {
|
|
Name string `json:"name" example:"SportsBook"`
|
|
Description string `json:"description" example:"Betting on sport events"`
|
|
}
|
|
|
|
type BranchRes struct {
|
|
Name string `json:"name" example:"4-kilo Branch"`
|
|
Location string `json:"location" example:"Addis Ababa"`
|
|
WalletID int64 `json:"wallet_id" example:"1"`
|
|
BranchManagerID int64 `json:"branch_manager_id" example:"1"`
|
|
CompanyID int64 `json:"company_id" example:"1"`
|
|
IsSelfOwned bool `json:"is_self_owned" example:"false"`
|
|
}
|
|
|
|
type BranchDetailRes struct {
|
|
Name string `json:"name" example:"4-kilo Branch"`
|
|
Location string `json:"location" example:"Addis Ababa"`
|
|
WalletID int64 `json:"wallet_id" example:"1"`
|
|
BranchManagerID int64 `json:"branch_manager_id" example:"1"`
|
|
CompanyID int64 `json:"company_id" example:"1"`
|
|
IsSelfOwned bool `json:"is_self_owned" example:"false"`
|
|
ManagerName string `json:"manager_name" example:"John Smith"`
|
|
ManagerPhoneNumber string `json:"manager_phone_number" example:"0911111111"`
|
|
}
|
|
|
|
func convertBranch(branch domain.Branch) BranchRes {
|
|
return BranchRes{
|
|
Name: branch.Name,
|
|
Location: branch.Location,
|
|
WalletID: branch.WalletID,
|
|
BranchManagerID: branch.BranchManagerID,
|
|
CompanyID: branch.CompanyID,
|
|
IsSelfOwned: branch.IsSelfOwned,
|
|
}
|
|
}
|
|
|
|
func convertBranchDetail(branch domain.BranchDetail) BranchDetailRes {
|
|
return BranchDetailRes{
|
|
Name: branch.Name,
|
|
Location: branch.Location,
|
|
WalletID: branch.WalletID,
|
|
BranchManagerID: branch.BranchManagerID,
|
|
CompanyID: branch.CompanyID,
|
|
IsSelfOwned: branch.IsSelfOwned,
|
|
ManagerName: branch.ManagerName,
|
|
ManagerPhoneNumber: branch.ManagerPhoneNumber,
|
|
}
|
|
}
|
|
|
|
// CreateBranch godoc
|
|
// @Summary Create a branch
|
|
// @Description Creates a branch
|
|
// @Tags branch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param createBranch body CreateBranchReq true "Creates branch"
|
|
// @Success 200 {object} BranchRes
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /branch [post]
|
|
func CreateBranch(logger *slog.Logger, branchSvc *branch.Service, walletSvc *wallet.Service, validator *customvalidator.CustomValidator) fiber.Handler {
|
|
return func(c *fiber.Ctx) error {
|
|
// Check if user is either branch manager / super main
|
|
// role := string(c.Locals("role").(domain.Role))
|
|
|
|
// if role != string(domain.RoleAdmin) && role != string(domain.RoleSuperAdmin) && role != string(domain.RoleBranchManager) {
|
|
// logger.Error("Unauthorized access", "role", role)
|
|
// return response.WriteJSON(c, fiber.StatusUnauthorized, "Unauthorized access", nil, nil)
|
|
// }
|
|
|
|
var req CreateBranchReq
|
|
|
|
if err := c.BodyParser(&req); err != nil {
|
|
logger.Error("CreateBranchReq failed", "error", err)
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"error": "Invalid request",
|
|
})
|
|
}
|
|
|
|
valErrs, ok := validator.Validate(c, req)
|
|
if !ok {
|
|
response.WriteJSON(c, fiber.StatusBadRequest, "Invalid request", valErrs, nil)
|
|
return nil
|
|
}
|
|
|
|
// Create Branch Wallet
|
|
newWallet, err := walletSvc.CreateWallet(c.Context(), domain.CreateWallet{
|
|
IsWithdraw: false,
|
|
IsBettable: true,
|
|
IsTransferable: true,
|
|
UserID: req.BranchManagerID,
|
|
})
|
|
|
|
if err != nil {
|
|
logger.Error("Create Branch Wallet failed", "error", err)
|
|
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to create branch wallet", err, nil)
|
|
}
|
|
|
|
branch, err := branchSvc.CreateBranch(c.Context(), domain.CreateBranch{
|
|
Name: req.Name,
|
|
Location: req.Location,
|
|
WalletID: newWallet.ID,
|
|
BranchManagerID: req.BranchManagerID,
|
|
CompanyID: req.CompanyID,
|
|
IsSelfOwned: req.IsSelfOwned,
|
|
})
|
|
|
|
if err != nil {
|
|
logger.Error("CreateBranchReq failed", "error", err)
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
|
|
"error": "Internal server error",
|
|
})
|
|
}
|
|
|
|
res := convertBranch(branch)
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Branch Created", res, nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// CreateSupportedOperation godoc
|
|
// @Summary Create a supported operation
|
|
// @Description Creates a supported operation
|
|
// @Tags branch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param createSupportedOperation body CreateSupportedOperationReq true "Creates supported operation"
|
|
// @Success 200 {object} SupportedOperationRes
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /supportedOperation [post]
|
|
func CreateSupportedOperation(logger *slog.Logger, branchSvc *branch.Service, validator *customvalidator.CustomValidator) fiber.Handler {
|
|
return func(c *fiber.Ctx) error {
|
|
var req CreateSupportedOperationReq
|
|
|
|
if err := c.BodyParser(&req); err != nil {
|
|
logger.Error("CreateSupportedOperationReq failed", "error", err)
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"error": "Invalid request",
|
|
})
|
|
}
|
|
valErrs, ok := validator.Validate(c, req)
|
|
if !ok {
|
|
response.WriteJSON(c, fiber.StatusBadRequest, "Invalid request", valErrs, nil)
|
|
return nil
|
|
}
|
|
operation, err := branchSvc.CreateSupportedOperation(c.Context(), domain.CreateSupportedOperation{
|
|
Name: req.Name,
|
|
Description: req.Description,
|
|
})
|
|
|
|
if err != nil {
|
|
logger.Error("CreateSupportedOperationReq failed", "error", err)
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
|
|
"error": "Internal server error",
|
|
})
|
|
}
|
|
|
|
res := SupportedOperationRes{
|
|
Name: operation.Name,
|
|
Description: operation.Description,
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Operation Created", res, nil)
|
|
|
|
}
|
|
}
|
|
|
|
// CreateBranchOperation godoc
|
|
// @Summary Create a operation
|
|
// @Description Creates a operation
|
|
// @Tags branch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param createBranchOperation body CreateBranchOperationReq true "Creates operation"
|
|
// @Success 200 {object} BranchOperationRes
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /operation [post]
|
|
func CreateBranchOperation(logger *slog.Logger, branchSvc *branch.Service, validator *customvalidator.CustomValidator) fiber.Handler {
|
|
return func(c *fiber.Ctx) error {
|
|
var req CreateBranchOperationReq
|
|
if err := c.BodyParser(&req); err != nil {
|
|
logger.Error("CreateBranchOperationReq failed", "error", err)
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"error": "Invalid request",
|
|
})
|
|
}
|
|
|
|
valErrs, ok := validator.Validate(c, req)
|
|
if !ok {
|
|
response.WriteJSON(c, fiber.StatusBadRequest, "Invalid request", valErrs, nil)
|
|
return nil
|
|
}
|
|
|
|
err := branchSvc.CreateBranchOperation(c.Context(), domain.CreateBranchOperation{
|
|
BranchID: req.BranchID,
|
|
OperationID: req.OperationID,
|
|
})
|
|
|
|
if err != nil {
|
|
logger.Error("CreateBranchOperationReq failed", "error", err)
|
|
return response.WriteJSON(c, fiber.StatusInternalServerError, "Internal Server Error", err, nil)
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Branch Operation Created", nil, nil)
|
|
|
|
}
|
|
}
|
|
|
|
// GetBranchByID godoc
|
|
// @Summary Gets branch by id
|
|
// @Description Gets a single branch by id
|
|
// @Tags branch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path int true "Branch ID"
|
|
// @Success 200 {object} BranchDetailRes
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /branch/{id} [get]
|
|
func GetBranchByID(logger *slog.Logger, branchSvc *branch.Service, validator *customvalidator.CustomValidator) fiber.Handler {
|
|
return func(c *fiber.Ctx) error {
|
|
branchID := c.Params("id")
|
|
id, err := strconv.ParseInt(branchID, 10, 64)
|
|
if err != nil {
|
|
logger.Error("Invalid branch ID", "branchID", branchID, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid branch ID", err, nil)
|
|
}
|
|
|
|
branch, err := branchSvc.GetBranchByID(c.Context(), id)
|
|
|
|
if err != nil {
|
|
logger.Error("Failed to get branch by ID", "branchID", id, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve branch", err, nil)
|
|
}
|
|
|
|
res := convertBranchDetail(branch)
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Branch retrieved successfully", res, nil)
|
|
|
|
}
|
|
}
|
|
|
|
// GetBranchByManagerID godoc
|
|
// @Summary Gets branches by manager id
|
|
// @Description Gets a branches by manager id
|
|
// @Tags branch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path int true "User ID"
|
|
// @Success 200 {array} BranchDetailRes
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /manager/{id}/branch [get]
|
|
func GetBranchByManagerID(logger *slog.Logger, branchSvc *branch.Service, validator *customvalidator.CustomValidator) fiber.Handler {
|
|
return func(c *fiber.Ctx) error {
|
|
|
|
// TODO: Restrict any who isn't branch manager or higher
|
|
userID := c.Params("id")
|
|
id, err := strconv.ParseInt(userID, 10, 64)
|
|
if err != nil {
|
|
logger.Error("Invalid user ID", "userID", userID, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid user ID", err, nil)
|
|
}
|
|
|
|
branches, err := branchSvc.GetBranchByManagerID(c.Context(), id)
|
|
|
|
if err != nil {
|
|
logger.Error("Failed to get branches", "error", err)
|
|
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to get branches", err, nil)
|
|
}
|
|
var result []BranchDetailRes = make([]BranchDetailRes, len(branches))
|
|
for _, branch := range branches {
|
|
result = append(result, convertBranchDetail(branch))
|
|
}
|
|
return response.WriteJSON(c, fiber.StatusOK, "Branches for Branch Manager retrieved", result, nil)
|
|
}
|
|
}
|
|
|
|
// GetBranchByCompanyID godoc
|
|
// @Summary Gets branches by company id
|
|
// @Description Gets branches by company id
|
|
// @Tags branch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path int true "Company ID"
|
|
// @Success 200 {array} BranchDetailRes
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /company/{id}/branch [get]
|
|
func GetBranchByCompanyID(logger *slog.Logger, branchSvc *branch.Service, validator *customvalidator.CustomValidator) fiber.Handler {
|
|
return func(c *fiber.Ctx) error {
|
|
companyID := c.Params("id")
|
|
id, err := strconv.ParseInt(companyID, 10, 64)
|
|
if err != nil {
|
|
logger.Error("Invalid company ID", "companyID", companyID, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid company ID", err, nil)
|
|
}
|
|
|
|
branches, err := branchSvc.GetBranchByCompanyID(c.Context(), id)
|
|
if err != nil {
|
|
logger.Error("Failed to get branches", "error", err)
|
|
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to get branches", err, nil)
|
|
}
|
|
|
|
var result []BranchDetailRes = make([]BranchDetailRes, len(branches))
|
|
for _, branch := range branches {
|
|
result = append(result, convertBranchDetail(branch))
|
|
}
|
|
return response.WriteJSON(c, fiber.StatusOK, "Branches for Company retrieved", result, nil)
|
|
}
|
|
}
|
|
|
|
// GetAllBranches godoc
|
|
// @Summary Gets all branches
|
|
// @Description Gets all branches
|
|
// @Tags branch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Success 200 {array} BranchDetailRes
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /branch [get]
|
|
func GetAllBranches(logger *slog.Logger, branchSvc *branch.Service, validator *customvalidator.CustomValidator) fiber.Handler {
|
|
return func(c *fiber.Ctx) error {
|
|
branches, err := branchSvc.GetAllBranches(c.Context())
|
|
if err != nil {
|
|
logger.Error("Failed to get branches", "error", err)
|
|
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to get branches", err, nil)
|
|
}
|
|
|
|
var result []BranchDetailRes = make([]BranchDetailRes, len(branches))
|
|
for _, branch := range branches {
|
|
result = append(result, convertBranchDetail(branch))
|
|
}
|
|
return response.WriteJSON(c, fiber.StatusOK, "Branches for Company retrieved", result, nil)
|
|
|
|
}
|
|
}
|
|
|
|
// GetBranchOperations godoc
|
|
// @Summary Gets branch operations
|
|
// @Description Gets branch operations
|
|
// @Tags branch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path int true "Branch ID"
|
|
// @Success 200 {array} BranchOperationRes
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /branch/{id}/operation [get]
|
|
func GetBranchOperations(logger *slog.Logger, branchSvc *branch.Service, validator *customvalidator.CustomValidator) fiber.Handler {
|
|
return func(c *fiber.Ctx) error {
|
|
|
|
branchID := c.Params("id")
|
|
id, err := strconv.ParseInt(branchID, 10, 64)
|
|
if err != nil {
|
|
logger.Error("Invalid branch ID", "branchID", branchID, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid branch ID", err, nil)
|
|
}
|
|
|
|
operations, err := branchSvc.GetBranchOperations(c.Context(), id)
|
|
|
|
if err != nil {
|
|
logger.Error("Failed to get operation by ID", "branchID", id, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve operation", err, nil)
|
|
}
|
|
|
|
var result []BranchOperationRes = make([]BranchOperationRes, len(operations))
|
|
|
|
for _, branch := range operations {
|
|
result = append(result, BranchOperationRes{
|
|
Name: branch.OperationName,
|
|
Description: branch.OperationDescription,
|
|
})
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Branch Operations retrieved successfully", result, nil)
|
|
}
|
|
}
|
|
|
|
// UpdateBranch godoc
|
|
// @Summary Updates a branch
|
|
// @Description Updates a branch
|
|
// @Tags branch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path int true "Branch ID"
|
|
// @Param updateBranch body CreateBranchReq true "Update Branch"
|
|
// @Success 200 {object} BranchRes
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /branch/{id} [put]
|
|
func UpdateBranch(logger *slog.Logger, branchSvc *branch.Service, validator *customvalidator.CustomValidator) fiber.Handler {
|
|
return func(c *fiber.Ctx) error {
|
|
branchID := c.Params("id")
|
|
id, err := strconv.ParseInt(branchID, 10, 64)
|
|
if err != nil {
|
|
logger.Error("Invalid branch ID", "branchID", branchID, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid branch ID", err, nil)
|
|
}
|
|
|
|
var req CreateBranchReq
|
|
|
|
if err := c.BodyParser(&req); err != nil {
|
|
logger.Error("CreateBranchReq failed", "error", err)
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"error": "Invalid request",
|
|
})
|
|
}
|
|
valErrs, ok := validator.Validate(c, req)
|
|
if !ok {
|
|
response.WriteJSON(c, fiber.StatusBadRequest, "Invalid request", valErrs, nil)
|
|
return nil
|
|
}
|
|
|
|
branch, err := branchSvc.UpdateBranch(c.Context(), id, domain.UpdateBranch{
|
|
Name: req.Name,
|
|
Location: req.Location,
|
|
BranchManagerID: req.BranchManagerID,
|
|
CompanyID: req.CompanyID,
|
|
IsSelfOwned: req.IsSelfOwned,
|
|
})
|
|
|
|
if err != nil {
|
|
logger.Error("Failed to update branch", "branchID", id, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to update branch", err, nil)
|
|
}
|
|
|
|
res := convertBranch(branch)
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Branch Updated", res, nil)
|
|
|
|
}
|
|
}
|
|
|
|
// DeleteBranch godoc
|
|
// @Summary Delete the branch
|
|
// @Description Delete the branch
|
|
// @Tags branch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path int true "Branch ID""
|
|
// @Success 200 {object} response.APIResponse
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /branch/{id} [delete]
|
|
func DeleteBranch(logger *slog.Logger, branchSvc *branch.Service, validator *customvalidator.CustomValidator) fiber.Handler {
|
|
return func(c *fiber.Ctx) error {
|
|
|
|
branchID := c.Params("id")
|
|
id, err := strconv.ParseInt(branchID, 10, 64)
|
|
|
|
if err != nil {
|
|
logger.Error("Invalid Branch ID", "branchID", branchID, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid Branch ID", err, nil)
|
|
}
|
|
|
|
err = branchSvc.DeleteBranch(c.Context(), id)
|
|
|
|
if err != nil {
|
|
logger.Error("Failed to delete by ID", "Branch ID", id, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to Delete Branch", err, nil)
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Branch removed successfully", nil, nil)
|
|
|
|
}
|
|
}
|
|
|
|
// DeleteBranchOperation godoc
|
|
// @Summary Delete the branch operation
|
|
// @Description Delete the branch operation
|
|
// @Tags branch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path int true "Branch ID"
|
|
// @Param opID path int true "Branch Operation ID"
|
|
// @Success 200 {object} response.APIResponse
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /branch/{id}/operation/{opID} [delete]
|
|
func DeleteBranchOperation(logger *slog.Logger, branchSvc *branch.Service, validator *customvalidator.CustomValidator) fiber.Handler {
|
|
return func(c *fiber.Ctx) error {
|
|
branchID := c.Params("id")
|
|
opID := c.Params("opID")
|
|
|
|
id, err := strconv.ParseInt(branchID, 10, 64)
|
|
|
|
if err != nil {
|
|
logger.Error("Invalid Branch ID", "branchID", branchID, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid Branch ID", err, nil)
|
|
}
|
|
|
|
operationID, err := strconv.ParseInt(opID, 10, 64)
|
|
|
|
if err != nil {
|
|
logger.Error("Invalid Operation ID", "operationID", opID, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid Operation ID", err, nil)
|
|
}
|
|
|
|
err = branchSvc.DeleteBranchOperation(c.Context(), id, operationID)
|
|
|
|
if err != nil {
|
|
logger.Error("Failed to delete operation", "Branch ID", id, "error", err)
|
|
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to Delete Operation", err, nil)
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Branch Operation removed successfully", nil, nil)
|
|
|
|
}
|
|
}
|