357 lines
9.3 KiB
Go
357 lines
9.3 KiB
Go
package controllers
|
|
|
|
import (
|
|
"log"
|
|
"nearle/models"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"nearle/services"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
)
|
|
|
|
type OrderController struct {
|
|
orderService services.OrderService
|
|
}
|
|
|
|
func NewOrderController(orderService services.OrderService) *OrderController {
|
|
return &OrderController{orderService: orderService}
|
|
}
|
|
|
|
func (ctl *OrderController) GetOrders(c *fiber.Ctx) error {
|
|
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
cid, _ := strconv.Atoi(c.Query("customerid"))
|
|
mid, _ := strconv.Atoi(c.Query("moduleid"))
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
uid, _ := strconv.Atoi(c.Query("appuserid"))
|
|
lid, _ := strconv.Atoi(c.Query("locationid"))
|
|
configid, _ := strconv.Atoi(c.Query("configid"))
|
|
|
|
stat := c.Query("status")
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
keyword := c.Query("keyword")
|
|
|
|
pageno, _ := strconv.Atoi(c.Query("pageno"))
|
|
pagesize, _ := strconv.Atoi(c.Query("pagesize"))
|
|
|
|
if pageno <= 0 {
|
|
pageno = 1
|
|
}
|
|
if pagesize <= 0 {
|
|
pagesize = 10
|
|
}
|
|
|
|
// Build dynamic query struct
|
|
query := models.DeliveryQuery{
|
|
Tenantid: tid,
|
|
Partnerid: pid,
|
|
Customerid: cid,
|
|
Moduleid: mid,
|
|
Applocationid: aid,
|
|
Locationid: lid,
|
|
UserID: uid,
|
|
Appuserid: uid,
|
|
Configid: configid,
|
|
Fromdate: fdate,
|
|
ToDate: tdate,
|
|
Status: stat,
|
|
Keyword: keyword,
|
|
Pageno: pageno,
|
|
Pagesize: pagesize,
|
|
}
|
|
|
|
var (
|
|
orders []models.OrderInfo
|
|
err error
|
|
)
|
|
|
|
// --------------------------
|
|
// 🔥 DYNAMIC ROUTING LOGIC
|
|
// --------------------------
|
|
|
|
if tid != 0 && lid != 0 {
|
|
// ⭐ Both tenant & location → special handler
|
|
orders, err = ctl.orderService.GetTenantLocationOrders(query)
|
|
|
|
} else if tid != 0 {
|
|
// Tenant only
|
|
orders, err = ctl.orderService.GetTenantOrders(query)
|
|
|
|
} else if pid != 0 {
|
|
// Partner
|
|
orders, err = ctl.orderService.GetPartnerOrders(stat, fdate, tdate, pid, pageno, pagesize, keyword)
|
|
|
|
} else if cid != 0 {
|
|
// Customer
|
|
orders, err = ctl.orderService.GetCustomerOrders(stat, fdate, tdate, cid, mid, pageno, pagesize, keyword)
|
|
|
|
} else if aid != 0 {
|
|
// App-location orders
|
|
orders, err = ctl.orderService.GetAdminOrders(stat, fdate, tdate, aid, pageno, pagesize, keyword)
|
|
|
|
} else if uid != 0 {
|
|
// User orders
|
|
orders, err = ctl.orderService.GetUserOrders(stat, fdate, tdate, uid, pageno, pagesize, keyword)
|
|
|
|
} else {
|
|
// All orders
|
|
orders, err = ctl.orderService.GetAllOrders(stat, fdate, tdate, pageno, pagesize, keyword)
|
|
}
|
|
|
|
if err != nil {
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusInternalServerError,
|
|
"message": err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": true,
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"details": orders,
|
|
})
|
|
}
|
|
|
|
|
|
func (ctl *OrderController) GetOrderSummary(c *fiber.Ctx) error {
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
cid, _ := strconv.Atoi(c.Query("customerid"))
|
|
lid, _ := strconv.Atoi(c.Query("locationid"))
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
|
|
data, err := ctl.orderService.GetOrderSummary(tid, pid, cid, lid, fdate, tdate)
|
|
if err != nil {
|
|
return c.Status(http.StatusConflict).JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
return c.Status(http.StatusOK).JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
}
|
|
|
|
|
|
func (ctl *OrderController) GetlocationOrderSummary(c *fiber.Ctx) error {
|
|
tenantIDStr := c.Query("tenantid")
|
|
tenantID, _ := strconv.Atoi(tenantIDStr)
|
|
|
|
data, err := ctl.orderService.GetLocationOrderSummary(tenantID)
|
|
if err != nil {
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusInternalServerError,
|
|
"message": err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.Status(http.StatusOK).JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
}
|
|
|
|
func (ctl *OrderController) GetOrderInsights(c *fiber.Ctx) error {
|
|
tenantIDStr := c.Query("tenantid")
|
|
tenantID, _ := strconv.Atoi(tenantIDStr)
|
|
|
|
insights, err := ctl.orderService.GetOrderInsights(tenantID)
|
|
if err != nil {
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
|
|
"status": false,
|
|
"message": "Failed to fetch order insights",
|
|
"error": err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": true,
|
|
"message": "Success",
|
|
"details": insights,
|
|
})
|
|
}
|
|
|
|
func (ctl *OrderController) GetOrderDetails(c *fiber.Ctx) error {
|
|
orderHeaderIDStr := c.Query("orderheaderid")
|
|
if orderHeaderIDStr == "" {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": 400,
|
|
"message": "orderheaderid is required",
|
|
"status": false,
|
|
"details": []interface{}{},
|
|
})
|
|
}
|
|
|
|
orderHeaderID, err := strconv.Atoi(orderHeaderIDStr)
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": 400,
|
|
"message": "invalid orderheaderid",
|
|
"status": false,
|
|
"details": []interface{}{},
|
|
})
|
|
}
|
|
|
|
details, err := ctl.orderService.GetOrderDetails(orderHeaderID)
|
|
if err != nil {
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
|
|
"code": 500,
|
|
"message": "Failed to fetch order details",
|
|
"status": false,
|
|
"details": []interface{}{},
|
|
})
|
|
}
|
|
|
|
var orderAmount, totalTaxAmount float64
|
|
if len(details) > 0 {
|
|
orderAmount = details[0].Orderamount
|
|
totalTaxAmount = details[0].Totaltaxamount
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": 200,
|
|
"pricedetails": fiber.Map{
|
|
"orderamount": orderAmount,
|
|
"totaltaxamount": totalTaxAmount,
|
|
},
|
|
"details": details,
|
|
"message": "Success",
|
|
"status": true,
|
|
})
|
|
}
|
|
|
|
func (ctl *OrderController) UpdateOrder(c *fiber.Ctx) error {
|
|
var order models.Orders
|
|
|
|
if err := c.BodyParser(&order); err != nil {
|
|
return c.Status(http.StatusBadRequest).JSON(fiber.Map{
|
|
"code": http.StatusBadRequest,
|
|
"message": "Invalid request body",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
if err := ctl.orderService.UpdateOrder(&order); err != nil {
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"code": http.StatusInternalServerError,
|
|
"message": "Error updating order",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
return c.Status(http.StatusAccepted).JSON(fiber.Map{
|
|
"code": http.StatusAccepted,
|
|
"message": "Success",
|
|
"status": true,
|
|
})
|
|
}
|
|
|
|
func (ctl *OrderController) CreateOrderv3(c *fiber.Ctx) error {
|
|
var data models.Orders
|
|
|
|
// 🛠️ Strategy 1: Try parsing direct object (for Apidog)
|
|
if err := c.BodyParser(&data); err != nil {
|
|
log.Println("BodyParser strategy 1 error:", err)
|
|
}
|
|
|
|
// 🛠️ Strategy 2: If Strategy 1 didn't find a Tenantid, try parsing wrapped object (for Mobile App)
|
|
if data.Tenantid == 0 {
|
|
type OrderWrapper struct {
|
|
Orders models.Orders `json:"orders"`
|
|
}
|
|
var wrapper OrderWrapper
|
|
if err := c.BodyParser(&wrapper); err == nil && wrapper.Orders.Tenantid != 0 {
|
|
data = wrapper.Orders
|
|
}
|
|
}
|
|
|
|
// Double check we have the required ID
|
|
if data.Tenantid == 0 {
|
|
return c.Status(http.StatusConflict).JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": "Tenant ID is required",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
if strings.TrimSpace(data.Orderdate) == "" {
|
|
data.Orderdate = time.Now().Format("2006-01-02 15:04:05")
|
|
}
|
|
if strings.TrimSpace(data.Deliverytime) == "" {
|
|
data.Deliverytime = time.Now().Format("2006-01-02 15:04:05")
|
|
}
|
|
|
|
order, err := ctl.orderService.CreateOrder(data)
|
|
if err != nil {
|
|
log.Println("CreateOrder service error:", err)
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"code": http.StatusInternalServerError,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
return c.Status(http.StatusOK).JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Order created successfully",
|
|
"status": true,
|
|
"details": order,
|
|
})
|
|
}
|
|
|
|
func (ctl *OrderController) GetCustomerOrders(c *fiber.Ctx) error {
|
|
customerID := c.Query("customerid")
|
|
tenantID := c.Query("tenantid")
|
|
moduleID := c.Query("moduleid")
|
|
fromDate := c.Query("fromdate")
|
|
toDate := c.Query("todate")
|
|
orderStatus := c.Query("orderstatus")
|
|
keyword := c.Query("keyword")
|
|
|
|
pageNo, _ := strconv.Atoi(c.Query("pageno", "1"))
|
|
pageSize, _ := strconv.Atoi(c.Query("pagesize", "10"))
|
|
|
|
if pageNo < 1 {
|
|
pageNo = 1
|
|
}
|
|
if pageSize < 1 {
|
|
pageSize = 10
|
|
}
|
|
offset := (pageNo - 1) * pageSize
|
|
|
|
orders, err := ctl.orderService.GetCustomerOrdersv3(customerID, tenantID, moduleID, fromDate, toDate, orderStatus, keyword, pageSize, offset)
|
|
if err != nil {
|
|
log.Println("GetCustomerOrders error:", err)
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"code": http.StatusInternalServerError,
|
|
"status": false,
|
|
"message": "Failed to fetch customer orders",
|
|
"error": err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"status": true,
|
|
"message": "Customer orders fetched successfully",
|
|
"data": orders,
|
|
})
|
|
}
|