449 lines
9.8 KiB
Go
449 lines
9.8 KiB
Go
package controllers
|
|
|
|
import (
|
|
"nearle/db"
|
|
"nearle/domain"
|
|
"nearle/models"
|
|
"nearle/utils"
|
|
"net/http"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
)
|
|
|
|
func CreateCustomer(c *fiber.Ctx) error {
|
|
|
|
var data models.Customers
|
|
var id int
|
|
|
|
if err := c.BodyParser(&data); err != nil {
|
|
utils.Error("CreateCustomer body parse error", "error", err)
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": http.StatusBadRequest,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
// return c.JSON(fiber.Map{
|
|
// "status": false,
|
|
// "code": http.StatusConflict,
|
|
// "message": "Customer Already available",
|
|
// })
|
|
|
|
cid := domain.CheckCustomer(data.Contactno)
|
|
if cid != 0 {
|
|
|
|
data.Customerid = cid
|
|
|
|
tcid := domain.CheckTenantCustomer(data.Customerid, data.Tenantid)
|
|
if tcid == 0 {
|
|
|
|
id = domain.CreateTenantCustomer(data)
|
|
|
|
} else {
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "Customer Already available",
|
|
})
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
id = domain.CreateCustomer(data)
|
|
|
|
}
|
|
|
|
if id != 0 {
|
|
|
|
result := domain.GetCustomer(id, "")
|
|
return c.JSON(fiber.Map{
|
|
"status": true,
|
|
"code": http.StatusCreated,
|
|
"message": "Successful",
|
|
"details": result,
|
|
})
|
|
|
|
} else {
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "Failed",
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func UpdateCustomer(c *fiber.Ctx) error {
|
|
|
|
var data models.Customers
|
|
|
|
if err := c.BodyParser(&data); err != nil {
|
|
utils.Error("UpdateCustomer body parse error", "error", err)
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": http.StatusBadRequest,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
result := domain.UpdateCustomer(data)
|
|
|
|
if !result.Status {
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "Failed",
|
|
})
|
|
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": true,
|
|
"code": http.StatusAccepted,
|
|
"message": "Customer update successful",
|
|
})
|
|
|
|
}
|
|
|
|
func GetCustomer(c *fiber.Ctx) error {
|
|
|
|
cid, _ := strconv.Atoi(c.Query("customerid"))
|
|
cno := c.Query("contactno")
|
|
|
|
result := domain.GetCustomer(cid, cno)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
|
|
}
|
|
|
|
func GetTenantCustomers(c *fiber.Ctx) error {
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
lid, _ := strconv.Atoi(c.Query("locationid"))
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
pageno, _ := strconv.Atoi(c.Query("pageno"))
|
|
pagesize, _ := strconv.Atoi(c.Query("pagesize"))
|
|
keyword := c.Query("keyword")
|
|
|
|
result := domain.GetTenantCustomers(tid, lid, aid, pageno, pagesize, keyword)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
}
|
|
|
|
func GetCustomersbytenent(c *fiber.Ctx) error {
|
|
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
lid, _ := strconv.Atoi(c.Query("locationid"))
|
|
|
|
//aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
|
|
result := domain.GetCustomerbytenant(tid, lid)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
|
|
}
|
|
|
|
func GetCustomersbyapplocation(c *fiber.Ctx) error {
|
|
|
|
tid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
|
|
result := domain.GetCustomerbyApplocation(tid)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
|
|
}
|
|
|
|
func GetallCustomers(c *fiber.Ctx) error {
|
|
pageno, _ := strconv.Atoi(c.Query("pageno"))
|
|
pagesize, _ := strconv.Atoi(c.Query("pagesize"))
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
keyword := c.Query("keyword") // <-- new param
|
|
|
|
result := domain.GetallCustomers(aid, pageno, pagesize, keyword)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
}
|
|
|
|
func SearchCustomer(c *fiber.Ctx) error {
|
|
|
|
keyword := c.Query("keyword")
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
|
|
result := domain.SearchCustomer(keyword, tid)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
|
|
}
|
|
|
|
func DeleteCustomer(c *fiber.Ctx) error {
|
|
|
|
cid, _ := strconv.Atoi(c.Query("customerid"))
|
|
|
|
count := GetCustomerOrderCount(cid)
|
|
|
|
if count == 0 {
|
|
|
|
tx := db.DB.Begin()
|
|
t1 := tx.Table("customers").Where("customerid = ?", cid).Delete(&models.Customers{})
|
|
if t1.Error != nil {
|
|
utils.Error("DeleteCustomer t1 delete error", "error", t1.Error)
|
|
tx.Rollback()
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusInternalServerError,
|
|
"message": "Error deleting customer",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
t2 := tx.Table("customerlocations").Where("customerid = ?", cid).Delete(&models.Customerlocations{})
|
|
if t2.Error != nil {
|
|
utils.Error("DeleteCustomer t2 delete error", "error", t2.Error)
|
|
tx.Rollback()
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusInternalServerError,
|
|
"message": "Error deleting customer",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
t3 := tx.Table("tenantcustomers").Where("customerid = ?", cid).Delete(&models.Tenantcustomers{})
|
|
if t3.Error != nil {
|
|
utils.Error("DeleteCustomer t3 delete error", "error", t3.Error)
|
|
tx.Rollback()
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusInternalServerError,
|
|
"message": "Error deleting customer",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
tx.Commit()
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
})
|
|
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": "Orders available for customers",
|
|
"status": false,
|
|
})
|
|
|
|
}
|
|
|
|
func CreateCustomerLocation(c *fiber.Ctx) error {
|
|
|
|
var data models.Customerlocations
|
|
|
|
if err := c.BodyParser(&data); err != nil {
|
|
utils.Error("CreateCustomerLocation body parse error", "error", err)
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": http.StatusBadRequest,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
id := domain.CreateCustomerLocation(data)
|
|
if id != 0 {
|
|
|
|
result := domain.GetCustomerLocation(id)
|
|
return c.JSON(result)
|
|
|
|
} else {
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "Failed",
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func GetCustomerLocations(c *fiber.Ctx) error {
|
|
|
|
cid, _ := strconv.Atoi(c.Query("customerid"))
|
|
|
|
result := domain.GetCustomerLocation(cid)
|
|
return c.JSON(result)
|
|
|
|
}
|
|
|
|
func CreateCustomerRequest(c *fiber.Ctx) error {
|
|
var req models.CustomerRequest
|
|
|
|
if err := c.BodyParser(&req); err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": 400,
|
|
"message": "Invalid request body",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
now := time.Now()
|
|
req.Created = now
|
|
req.Updated = now
|
|
|
|
// Insert into database
|
|
if err := db.DB.Table("customerrequest").Create(&req).Error; err != nil {
|
|
utils.Error("CreateCustomerRequest DB error", "error", err)
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
|
|
"code": 500,
|
|
"message": "Failed to create customer request",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
return c.Status(fiber.StatusCreated).JSON(fiber.Map{
|
|
"code": 201,
|
|
"message": "Customer request created successfully",
|
|
"status": true,
|
|
"data": req,
|
|
})
|
|
}
|
|
|
|
func GetCustomerRequests(c *fiber.Ctx) error {
|
|
customerIDStr := c.Query("customerid")
|
|
pageNoStr := c.Query("pageno", "1")
|
|
pageSizeStr := c.Query("pagesize", "10")
|
|
|
|
pageNo, _ := strconv.Atoi(pageNoStr)
|
|
pageSize, _ := strconv.Atoi(pageSizeStr)
|
|
|
|
if pageNo < 1 {
|
|
pageNo = 1
|
|
}
|
|
if pageSize < 1 {
|
|
pageSize = 10
|
|
}
|
|
offset := (pageNo - 1) * pageSize
|
|
|
|
var requests []models.CustomerRequest
|
|
query := db.DB.Table("customerrequest")
|
|
|
|
// Optional filter by customerid
|
|
if customerIDStr != "" {
|
|
customerID, err := strconv.Atoi(customerIDStr)
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": 400,
|
|
"message": "Invalid customerid",
|
|
"status": false,
|
|
})
|
|
}
|
|
if customerID != 0 {
|
|
query = query.Where("customerid = ?", customerID)
|
|
}
|
|
}
|
|
|
|
var total int64
|
|
query.Count(&total)
|
|
|
|
if err := query.Order("created desc").Offset(offset).Limit(pageSize).Find(&requests).Error; err != nil {
|
|
utils.Error("GetCustomerRequests DB error", "error", err)
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
|
|
"code": 500,
|
|
"message": "Failed to fetch customer requests",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"code": 200,
|
|
"message": "Customer requests fetched successfully",
|
|
"status": true,
|
|
"data": requests,
|
|
})
|
|
}
|
|
|
|
func GetCustomerSummary(c *fiber.Ctx) error {
|
|
aid, _ := strconv.Atoi(c.Query("applocationid", "0"))
|
|
tid, _ := strconv.Atoi(c.Query("tenantid", "0"))
|
|
|
|
// Initialize query builder
|
|
query := db.DB.Table("customers as a").
|
|
Joins("INNER JOIN customerlocations b ON a.customerid = b.customerid").
|
|
Where("b.primaryaddress = 1")
|
|
|
|
if aid != 0 {
|
|
query = query.Where("a.applocationid = ?", aid)
|
|
}
|
|
|
|
if tid != 0 {
|
|
query = query.Joins("INNER JOIN tenantcustomers ct ON a.customerid = ct.customerid").
|
|
Where("ct.tenantid = ?", tid)
|
|
}
|
|
|
|
type Summary struct {
|
|
Total int64
|
|
Active int64
|
|
Inactive int64
|
|
}
|
|
|
|
var summary Summary
|
|
|
|
// Execute consolidated summary counts
|
|
err := query.Select(`
|
|
COUNT(DISTINCT a.customerid) AS total,
|
|
COUNT(DISTINCT CASE WHEN a.status = 0 THEN a.customerid END) AS active,
|
|
COUNT(DISTINCT CASE WHEN a.status = 1 THEN a.customerid END) AS inactive`).
|
|
Scan(&summary).Error
|
|
|
|
if err != nil {
|
|
utils.Error("GetCustomerSummary DB error", "error", err)
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"code": http.StatusInternalServerError,
|
|
"message": "Failed to fetch customer summary",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Customer summary fetched successfully",
|
|
"status": true,
|
|
"summary": summary,
|
|
})
|
|
}
|