1486 lines
40 KiB
Go
1486 lines
40 KiB
Go
package controllers
|
|
|
|
import (
|
|
"nearle/db"
|
|
"nearle/domain"
|
|
"nearle/models"
|
|
"nearle/utils"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
)
|
|
|
|
const (
|
|
core = `SELECT COUNT(DISTINCT a.deliveryid) AS total,
|
|
|
|
COUNT(DISTINCT CASE WHEN a.orderstatus = 'pending' THEN a.deliveryid END) AS pending,
|
|
COUNT(DISTINCT CASE WHEN a.orderstatus = 'accepted' THEN a.deliveryid END) AS accepted,
|
|
COUNT(DISTINCT CASE WHEN a.orderstatus = 'arrived' THEN a.deliveryid END) AS arrived,
|
|
COUNT(DISTINCT CASE WHEN a.orderstatus = 'picked' THEN a.deliveryid END) AS picked,
|
|
COUNT(DISTINCT CASE WHEN a.orderstatus = 'active' THEN a.deliveryid END) AS active,
|
|
COUNT(DISTINCT CASE WHEN a.orderstatus = 'delivered' THEN a.deliveryid END) AS delivered,
|
|
COUNT(DISTINCT CASE WHEN a.orderstatus = 'cancelled' THEN a.deliveryid END) AS cancelled,
|
|
COUNT(DISTINCT CASE WHEN a.orderstatus = 'skipped' THEN a.deliveryid END) AS skipped`
|
|
|
|
reports = `SELECT
|
|
c.userid,e.firstname,e.lastname,e.contactno AS ridercontact,b.tenantid,b.tenantname,a.locationid, d.locationname,
|
|
COUNT(*) AS totalorders,
|
|
SUM(CASE WHEN a.orderstatus = 'created' THEN 1 ELSE 0 END) AS orderscreated,
|
|
SUM(CASE WHEN a.orderstatus = 'pending' THEN 1 ELSE 0 END) AS orderspending,
|
|
SUM(CASE WHEN a.orderstatus = 'cancelled' THEN 1 ELSE 0 END) AS orderscancelled,
|
|
SUM(CASE WHEN a.orderstatus = 'delivered' THEN 1 ELSE 0 END) AS orderscompleted,
|
|
SUM(CASE WHEN c.orderstatus = 'pending' THEN 1 ELSE 0 END) AS deliveriespending,
|
|
SUM(CASE WHEN c.orderstatus = 'delivered' THEN 1 ELSE 0 END) AS deliveriescompleted,
|
|
SUM(CASE WHEN c.orderstatus = 'cancelled' THEN 1 ELSE 0 END) AS deliveriescancelled,
|
|
SUM(CASE WHEN c.paymenttype = 64 THEN c.deliveryamt ELSE 0 END) AS paylater,
|
|
SUM(CASE WHEN c.paymenttype = 43 THEN c.deliveryamt ELSE 0 END) AS payondelivery,
|
|
ROUND(SUM(CAST(COALESCE(NULLIF(c.kms, ''), '0') AS NUMERIC)), 2) AS kms,
|
|
ROUND(SUM(CAST(COALESCE(NULLIF(c.actualkms, ''), '0') AS NUMERIC)), 2) AS actualkms,
|
|
SUM(c.deliveryamt) AS charges,
|
|
SUM(CASE WHEN c.orderstatus = 'delivered' THEN c.cumulativekms ELSE 0 END) AS cumulativekms,
|
|
SUM(CASE WHEN c.orderstatus = 'delivered' THEN c.deliveryamt ELSE 0 END) AS deliveryamt,
|
|
SUM(c.previouskms) AS previouskms,
|
|
SUM(c.previouskms) AS previouskms,
|
|
SUM(CAST(COALESCE(NULLIF(c.riderkms, ''), '0') AS NUMERIC)) AS riderkms,
|
|
SUM(c.quantity) AS quantity, SUM(c.collectionamt) AS collectionamt, SUM(c.collectedamt) AS collectedamt, c.collectionstatus
|
|
FROM
|
|
tenants b
|
|
right JOIN orders a ON b.tenantid = a.tenantid
|
|
right JOIN deliveries c ON a.orderheaderid = c.orderheaderid
|
|
LEFT JOIN tenantlocations d ON a.locationid = d.locationid
|
|
LEFT JOIN app_users e ON e.userid = c.userid`
|
|
|
|
Ridersummary = `SELECT a.userid, a.firstname, a.lastname, a.contactno AS ridercontact, MAX(b.tenantid) AS tenantid, MAX(c.tenantname) AS tenantname, MAX(b.locationid) AS locationid, MAX(d.locationname) AS locationname,
|
|
CONCAT(a.firstname, ' ', a.lastname) AS fullname, a.status, SUM(COALESCE(b.quantity,0)) AS quantity, SUM(COALESCE(b.collectionamt,0)) AS collectionamt, SUM(COALESCE(b.collectedamt,0)) AS collectedamt, COALESCE(MAX(b.collectionstatus),0) AS collectionstatus,
|
|
COUNT(b.orderid) AS totalorders,
|
|
SUM(CASE WHEN b.orderstatus = 'pending' THEN 1 ELSE 0 END) AS pending,
|
|
SUM(CASE WHEN b.orderstatus = 'assigned' THEN 1 ELSE 0 END) AS assigned,
|
|
SUM(CASE WHEN b.orderstatus = 'accepted' THEN 1 ELSE 0 END) AS accepted,
|
|
SUM(CASE WHEN b.orderstatus = 'arrived' THEN 1 ELSE 0 END) AS arrived,
|
|
SUM(CASE WHEN b.orderstatus = 'picked' THEN 1 ELSE 0 END) AS picked,
|
|
SUM(CASE WHEN b.orderstatus = 'active' THEN 1 ELSE 0 END) AS active,
|
|
SUM(CASE WHEN b.orderstatus = 'skipped' THEN 1 ELSE 0 END) AS skipped,
|
|
SUM(CASE WHEN b.orderstatus = 'delivered' THEN 1 ELSE 0 END) AS delivered,
|
|
SUM(CASE WHEN b.orderstatus = 'cancelled' THEN 1 ELSE 0 END) AS cancelled,
|
|
SUM(CASE WHEN b.orderstatus = 'delivered' THEN CAST(COALESCE(NULLIF(b.actualkms, ''), '0') AS NUMERIC) ELSE 0 END) AS actualkms,
|
|
SUM(CASE WHEN b.orderstatus = 'delivered' THEN CAST(COALESCE(NULLIF(b.kms, ''), '0') AS NUMERIC) ELSE 0 END) AS kms,
|
|
SUM(CASE WHEN b.paymenttype = 64 THEN b.deliveryamt ELSE 0 END) AS paylater,
|
|
SUM(CASE WHEN b.paymenttype = 43 THEN b.deliveryamt ELSE 0 END) AS payondelivery,
|
|
SUM(CASE WHEN b.orderstatus = 'delivered' THEN b.cumulativekms ELSE 0 END) AS cumulativekms,
|
|
SUM(CASE WHEN b.orderstatus = 'delivered' THEN b.deliveryamt ELSE 0 END) AS deliveryamt,
|
|
SUM(b.previouskms) AS previouskms
|
|
FROM app_users a
|
|
LEFT JOIN deliveries b ON a.userid = b.userid
|
|
LEFT JOIN tenants c ON b.tenantid = c.tenantid
|
|
LEFT JOIN tenantlocations d ON b.locationid = d.locationid`
|
|
)
|
|
|
|
func PublishLog(c *fiber.Ctx) error {
|
|
|
|
var data []models.Deliverylogs
|
|
|
|
if err := c.BodyParser(&data); err != nil {
|
|
return err
|
|
}
|
|
|
|
err := domain.PublishLog(data)
|
|
|
|
if err != nil {
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": err,
|
|
})
|
|
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": true,
|
|
"code": http.StatusOK,
|
|
"message": "successful",
|
|
})
|
|
|
|
}
|
|
|
|
func GetDeliverylogs(c *fiber.Ctx) error {
|
|
|
|
did, _ := strconv.Atoi(c.Query("deliveryid"))
|
|
|
|
result := domain.GetDeliverylogs(did)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
|
|
}
|
|
|
|
func GetDeliveriesV1(c *fiber.Ctx) error {
|
|
|
|
var result []models.Deliveryinfo
|
|
|
|
pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
cid, _ := strconv.Atoi(c.Query("customerid"))
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
aud, _ := strconv.Atoi(c.Query("appuserid"))
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
stat := c.Query("status")
|
|
|
|
var info models.DeliveryQuery
|
|
|
|
info.Partnerid = pid
|
|
info.Tenantid = tid
|
|
info.UserID = uid
|
|
info.Appuserid = aud
|
|
info.Applocationid = aid
|
|
info.Fromdate = fdate
|
|
info.ToDate = tdate
|
|
info.Status = stat
|
|
|
|
if tid != 0 {
|
|
|
|
result = domain.GetTenantDeliveries(info)
|
|
|
|
} else if pid != 0 {
|
|
|
|
result = domain.GetPartnerDeliveries(info)
|
|
|
|
} else if cid != 0 {
|
|
|
|
result = domain.GetCustomerDeliveries(info)
|
|
|
|
} else if aid != 0 {
|
|
|
|
result = domain.GetAdminDeliveries(info)
|
|
|
|
} else if uid != 0 {
|
|
|
|
result = domain.GetUserDeliveries(info)
|
|
|
|
} else if aud != 0 {
|
|
|
|
result = domain.GetAppUserDeliveries(info)
|
|
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
|
|
}
|
|
|
|
func GetDeliveriesV2(c *fiber.Ctx) error {
|
|
var result []models.Deliveryinfo
|
|
|
|
pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
lid, _ := strconv.Atoi(c.Query("locationid"))
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
cid, _ := strconv.Atoi(c.Query("customerid"))
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
aud, _ := strconv.Atoi(c.Query("appuserid"))
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
stat := c.Query("status")
|
|
keyword := c.Query("keyword")
|
|
|
|
pagenoStr := c.Query("pageno")
|
|
pagesizeStr := c.Query("pagesize")
|
|
|
|
var pageno, pagesize int
|
|
var err error
|
|
|
|
if pagenoStr != "" {
|
|
pageno, err = strconv.Atoi(pagenoStr)
|
|
if err != nil || pageno <= 0 {
|
|
pageno = 1
|
|
}
|
|
}
|
|
|
|
if pagesizeStr != "" {
|
|
pagesize, err = strconv.Atoi(pagesizeStr)
|
|
if err != nil || pagesize <= 0 {
|
|
pagesize = 10
|
|
}
|
|
}
|
|
|
|
info := models.DeliveryQuery{
|
|
Partnerid: pid,
|
|
Tenantid: tid,
|
|
Locationid: lid,
|
|
UserID: uid,
|
|
Appuserid: aud,
|
|
Applocationid: aid,
|
|
Fromdate: fdate,
|
|
ToDate: tdate,
|
|
Status: stat,
|
|
Pageno: pageno,
|
|
Pagesize: pagesize,
|
|
Keyword: keyword,
|
|
}
|
|
|
|
utils.Logger.Infow("Searching Delivery", "keyword", keyword)
|
|
|
|
switch {
|
|
case tid != 0 && lid != 0:
|
|
result = domain.GetTenantLocationDeliveries(info)
|
|
case tid != 0:
|
|
result = domain.GetTenantDeliveries(info)
|
|
case lid != 0:
|
|
result = domain.GetLocationDeliveries(info)
|
|
case pid != 0:
|
|
result = domain.GetPartnerDeliveries(info)
|
|
case cid != 0:
|
|
result = domain.GetCustomerDeliveries(info)
|
|
case aid != 0:
|
|
result = domain.GetAdminDeliveries(info)
|
|
case uid != 0:
|
|
result = domain.GetUserDeliveries(info)
|
|
case aud != 0:
|
|
result = domain.GetAppUserDeliveries(info)
|
|
default:
|
|
result = domain.GetDeliveries(info)
|
|
}
|
|
|
|
if result == nil {
|
|
result = []models.Deliveryinfo{}
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
}
|
|
|
|
func GetDeliveriesV3(c *fiber.Ctx) error {
|
|
var result []models.Deliveryinfo
|
|
|
|
pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
cid, _ := strconv.Atoi(c.Query("customerid"))
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
aud, _ := strconv.Atoi(c.Query("appuserid"))
|
|
pageno, _ := strconv.Atoi(c.Query("pageno", "1"))
|
|
pagesize, _ := strconv.Atoi(c.Query("pagesize", ""))
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
stat := c.Query("status")
|
|
keyword := c.Query("keyword")
|
|
|
|
var info models.DeliveryQuery
|
|
|
|
info.Partnerid = pid
|
|
info.Tenantid = tid
|
|
info.UserID = uid
|
|
info.Appuserid = aud
|
|
info.Applocationid = aid
|
|
info.Fromdate = fdate
|
|
info.ToDate = tdate
|
|
info.Status = stat
|
|
info.Pageno = pageno
|
|
info.Pagesize = pagesize
|
|
info.Keyword = keyword
|
|
|
|
utils.Logger.Infow("Searching Delivery", "keyword", keyword)
|
|
|
|
// Choose which delivery function to call
|
|
switch {
|
|
case tid != 0:
|
|
result = domain.GetTenantDeliveries(info)
|
|
case pid != 0:
|
|
result = domain.GetPartnerDeliveries(info)
|
|
case cid != 0:
|
|
result = domain.GetCustomerDeliveries(info)
|
|
case aid != 0:
|
|
result = domain.GetAdminDeliveries(info)
|
|
case uid != 0:
|
|
result = domain.GetUserDeliveriesv1(info)
|
|
case aud != 0:
|
|
result = domain.GetAppUserDeliveries(info)
|
|
default:
|
|
result = domain.GetDeliveries(info)
|
|
}
|
|
|
|
// Ensure result is not nil (avoid "null" in JSON)
|
|
if result == nil {
|
|
result = []models.Deliveryinfo{}
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
}
|
|
|
|
func GetDeliveries(c *fiber.Ctx) error {
|
|
|
|
pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
aud, _ := strconv.Atoi(c.Query("appuserid"))
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
stat := c.Query("status")
|
|
|
|
var info models.DeliveryQuery
|
|
|
|
info.Partnerid = pid
|
|
info.Tenantid = tid
|
|
info.UserID = uid
|
|
info.Appuserid = aud
|
|
info.Applocationid = aid
|
|
info.Fromdate = fdate
|
|
info.ToDate = tdate
|
|
info.Status = stat
|
|
|
|
data := domain.GetDeliveries(info)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
|
|
}
|
|
|
|
func GetReportSummary(c *fiber.Ctx) error {
|
|
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
|
|
var data []models.ReportSummary
|
|
var q1 string
|
|
|
|
var params []interface{}
|
|
q1 = reports
|
|
|
|
if tid != 0 {
|
|
q1 += " WHERE a.tenantid=? "
|
|
params = append(params, tid)
|
|
} else if pid != 0 {
|
|
q1 += " WHERE a.partnerid=? "
|
|
params = append(params, pid)
|
|
} else if uid != 0 {
|
|
q1 += " WHERE c.userid=? "
|
|
params = append(params, uid)
|
|
} else if aid != 0 {
|
|
q1 += " WHERE c.applocationid=? "
|
|
params = append(params, aid)
|
|
} else {
|
|
q1 += " WHERE 1=1 "
|
|
}
|
|
|
|
if fdate != "" && tdate != "" {
|
|
q1 += " AND a.orderdate::date between ?::date and ?::date "
|
|
params = append(params, fdate, tdate)
|
|
}
|
|
|
|
q1 += " GROUP BY a.tenantid, b.tenantname, c.userid, e.firstname, e.lastname, e.contactno, a.locationid, d.locationname, c.collectionstatus"
|
|
|
|
utils.Logger.Debugw("ReportSummary SQL generated", "query", q1)
|
|
|
|
db.DB.Raw(q1, params...).Find(&data)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
|
|
}
|
|
|
|
func GetReportLocationSummary(c *fiber.Ctx) error {
|
|
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
lid, _ := strconv.Atoi(c.Query("locationid"))
|
|
pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
keyword := c.Query("keyword")
|
|
|
|
var data []models.ReportSummary
|
|
var q1 string
|
|
|
|
var params []interface{}
|
|
q1 = reports + " WHERE 1=1 "
|
|
|
|
if tid != 0 {
|
|
q1 += " AND a.tenantid=? "
|
|
params = append(params, tid)
|
|
}
|
|
if lid != 0 {
|
|
q1 += " AND a.locationid=? "
|
|
params = append(params, lid)
|
|
}
|
|
if pid != 0 {
|
|
q1 += " AND a.partnerid=? "
|
|
params = append(params, pid)
|
|
}
|
|
if uid != 0 {
|
|
q1 += " AND c.userid=? "
|
|
params = append(params, uid)
|
|
}
|
|
if aid != 0 {
|
|
q1 += " AND c.applocationid=? "
|
|
params = append(params, aid)
|
|
}
|
|
if keyword != "" {
|
|
q1 += " AND LOWER(d.locationname) LIKE LOWER(?) "
|
|
params = append(params, "%"+keyword+"%")
|
|
}
|
|
if fdate != "" && tdate != "" {
|
|
q1 += " AND a.orderdate::date BETWEEN ?::date AND ?::date "
|
|
params = append(params, fdate, tdate)
|
|
}
|
|
|
|
q1 += " GROUP BY a.locationid, b.tenantid, b.tenantname, c.userid, e.firstname, e.lastname, e.contactno, d.locationname, c.collectionstatus"
|
|
|
|
utils.Logger.Debugw("ReportLocationSummary SQL generated", "query", q1)
|
|
|
|
db.DB.Raw(q1, params...).Scan(&data)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
}
|
|
|
|
func GetRiderLocationReportSummary(c *fiber.Ctx) error {
|
|
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
|
|
var data []models.ReportSummary
|
|
var q1 string
|
|
|
|
base := `
|
|
SELECT b.tenantid,b.tenantname,a.locationid,d.locationname,e.userid,e.firstname,e.lastname,
|
|
COUNT(*) AS totalorders,
|
|
SUM(CASE WHEN a.orderstatus = 'created' THEN 1 ELSE 0 END) AS orderscreated,
|
|
SUM(CASE WHEN a.orderstatus = 'pending' THEN 1 ELSE 0 END) AS orderspending,
|
|
SUM(CASE WHEN a.orderstatus = 'cancelled' THEN 1 ELSE 0 END) AS orderscancelled,
|
|
SUM(CASE WHEN a.orderstatus = 'delivered' THEN 1 ELSE 0 END) AS orderscompleted,
|
|
SUM(CASE WHEN c.orderstatus = 'pending' THEN 1 ELSE 0 END) AS deliveriespending,
|
|
SUM(CASE WHEN c.orderstatus = 'delivered' THEN 1 ELSE 0 END) AS deliveriescompleted,
|
|
SUM(CASE WHEN c.orderstatus = 'cancelled' THEN 1 ELSE 0 END) AS deliveriescancelled,
|
|
SUM(CASE WHEN c.paymenttype = 64 THEN c.deliveryamt ELSE 0 END) AS paylater,
|
|
SUM(CASE WHEN c.paymenttype = 43 THEN c.deliveryamt ELSE 0 END) AS payondelivery,
|
|
ROUND(SUM(CAST(COALESCE(NULLIF(c.kms, ''), '0') AS NUMERIC)), 2) AS kms,
|
|
ROUND(SUM(CAST(COALESCE(NULLIF(c.actualkms, ''), '0') AS NUMERIC)), 2) AS actualkms,
|
|
SUM(c.deliveryamt) AS charges
|
|
FROM tenants b
|
|
RIGHT JOIN orders a ON b.tenantid = a.tenantid
|
|
RIGHT JOIN deliveries c ON a.orderheaderid = c.orderheaderid
|
|
LEFT JOIN tenantlocations d ON a.locationid = d.locationid
|
|
LEFT JOIN app_users e ON e.userid = c.userid
|
|
`
|
|
|
|
// WHERE conditions
|
|
var where []string
|
|
var params []interface{}
|
|
|
|
// Tenant filter
|
|
if tid != 0 {
|
|
where = append(where, "a.tenantid=?")
|
|
params = append(params, tid)
|
|
}
|
|
|
|
// Partner filter
|
|
if pid != 0 {
|
|
where = append(where, "a.partnerid=?")
|
|
params = append(params, pid)
|
|
}
|
|
|
|
// Rider (userid) filter
|
|
if uid != 0 {
|
|
where = append(where, "c.userid=?")
|
|
params = append(params, uid)
|
|
}
|
|
|
|
// Location filter
|
|
if aid != 0 {
|
|
where = append(where, "a.locationid=?")
|
|
params = append(params, aid)
|
|
}
|
|
|
|
// Date filter
|
|
if fdate != "" && tdate != "" {
|
|
where = append(where, "a.orderdate::date BETWEEN ?::date AND ?::date")
|
|
where = append(where, "c.deliverydate::date BETWEEN ?::date AND ?::date")
|
|
params = append(params, fdate, tdate, fdate, tdate)
|
|
}
|
|
|
|
// Build WHERE clause
|
|
if len(where) > 0 {
|
|
q1 = base + " WHERE " + strings.Join(where, " AND ")
|
|
} else {
|
|
q1 = base
|
|
}
|
|
|
|
// GROUP BY
|
|
q1 += " GROUP BY a.locationid, b.tenantid, b.tenantname, d.locationname, e.userid, e.firstname, e.lastname"
|
|
|
|
utils.Logger.Debugw("RiderLocationReportSummary SQL generated", "query", q1)
|
|
|
|
db.DB.Raw(q1, params...).Find(&data)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
}
|
|
|
|
func GetRiderSummary(c *fiber.Ctx) error {
|
|
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
lid, _ := strconv.Atoi(c.Query("locationid"))
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
keyword := c.Query("keyword")
|
|
|
|
var data []models.Ridersummary
|
|
|
|
var params []interface{}
|
|
q1 := Ridersummary + " WHERE a.configid = 6"
|
|
|
|
if uid != 0 {
|
|
q1 += " AND a.userid=?"
|
|
params = append(params, uid)
|
|
}
|
|
|
|
if tid != 0 {
|
|
q1 += " AND b.tenantid=?"
|
|
params = append(params, tid)
|
|
}
|
|
|
|
if lid != 0 {
|
|
q1 += " AND b.locationid=?"
|
|
params = append(params, lid)
|
|
}
|
|
|
|
if aid != 0 {
|
|
q1 += " AND a.applocationid=?"
|
|
params = append(params, aid)
|
|
}
|
|
|
|
if pid != 0 {
|
|
q1 += " AND a.partnerid=?"
|
|
params = append(params, pid)
|
|
}
|
|
|
|
if fdate != "" && tdate != "" {
|
|
q1 += " AND b.deliverydate::date BETWEEN ?::date AND ?::date"
|
|
params = append(params, fdate, tdate)
|
|
}
|
|
|
|
if keyword != "" {
|
|
k := "%" + strings.ToLower(keyword) + "%"
|
|
q1 += " AND (LOWER(a.firstname) LIKE ? OR LOWER(a.lastname) LIKE ? OR LOWER(CONCAT(a.firstname, ' ', a.lastname)) LIKE ?)"
|
|
params = append(params, k, k, k)
|
|
}
|
|
|
|
q1 += " GROUP BY a.userid, a.firstname, a.lastname, a.contactno, a.status"
|
|
|
|
utils.Logger.Debugw("RiderSummary SQL generated", "query", q1)
|
|
|
|
db.DB.Raw(q1, params...).Scan(&data)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
}
|
|
|
|
func GetRiderLocationSummary(c *fiber.Ctx) error {
|
|
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
lid, _ := strconv.Atoi(c.Query("locationid"))
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
|
|
var data []models.Ridersummary
|
|
var q1 string
|
|
|
|
var params []interface{}
|
|
q1 = Ridersummary + " WHERE a.configid=6 "
|
|
|
|
if tid != 0 {
|
|
q1 += " AND b.tenantid=? "
|
|
params = append(params, tid)
|
|
}
|
|
if lid != 0 {
|
|
q1 += " AND b.locationid=? "
|
|
params = append(params, lid)
|
|
}
|
|
if aid != 0 {
|
|
q1 += " AND a.applocationid=? "
|
|
params = append(params, aid)
|
|
}
|
|
if pid != 0 {
|
|
q1 += " AND a.partnerid=? "
|
|
params = append(params, pid)
|
|
}
|
|
if fdate != "" && tdate != "" {
|
|
q1 += " AND b.deliverydate::date BETWEEN ?::date AND ?::date "
|
|
params = append(params, fdate, tdate)
|
|
}
|
|
|
|
q1 += " GROUP BY a.userid, b.locationid, a.firstname, a.lastname, a.contactno, b.tenantid, c.tenantname, d.locationname, a.status"
|
|
|
|
db.DB.Raw(q1, params...).Scan(&data)
|
|
|
|
utils.Logger.Debugw("RiderLocationSummary SQL generated", "query", q1)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": 200,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
}
|
|
|
|
func GetDeliverySummary(c *fiber.Ctx) error {
|
|
|
|
// 🔹 Query params
|
|
appuid, _ := strconv.Atoi(c.Query("appuserid"))
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
lid, _ := strconv.Atoi(c.Query("locationid"))
|
|
aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
|
|
status := c.Query("status")
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
|
|
var data models.DeliverySummary
|
|
var qb strings.Builder
|
|
var params []interface{}
|
|
|
|
qb.WriteString(core + `
|
|
FROM deliveries a
|
|
INNER JOIN tenants b ON a.tenantid = b.tenantid
|
|
INNER JOIN app_users c ON a.userid = c.userid
|
|
INNER JOIN tenantlocations e ON a.locationid = e.locationid
|
|
INNER JOIN app_location f ON a.applocationid = f.applocationid
|
|
INNER JOIN app_locationconfig g ON f.applocationid = g.applocationid
|
|
WHERE b.moduleid = 6
|
|
AND g.status = 'Active'
|
|
`)
|
|
|
|
if appuid != 0 {
|
|
qb.WriteString(" AND g.userid = ?")
|
|
params = append(params, appuid)
|
|
}
|
|
|
|
if tid != 0 {
|
|
qb.WriteString(" AND a.tenantid = ?")
|
|
params = append(params, tid)
|
|
}
|
|
|
|
if lid != 0 {
|
|
qb.WriteString(" AND a.locationid = ?")
|
|
params = append(params, lid)
|
|
}
|
|
|
|
if aid != 0 {
|
|
qb.WriteString(" AND a.applocationid = ?")
|
|
params = append(params, aid)
|
|
}
|
|
|
|
if uid != 0 {
|
|
qb.WriteString(" AND a.userid = ?")
|
|
params = append(params, uid)
|
|
}
|
|
|
|
if status != "" && strings.ToLower(status) != "all" {
|
|
qb.WriteString(" AND a.orderstatus = ?")
|
|
params = append(params, status)
|
|
}
|
|
|
|
// 🔹 DATE FILTER (INDEX-FRIENDLY)
|
|
if fdate != "" && tdate != "" {
|
|
qb.WriteString(`
|
|
AND a.deliverydate >= (CONCAT(?::text, ' 00:00:00'))::timestamp
|
|
AND a.deliverydate <= (CONCAT(?::text, ' 23:59:59'))::timestamp
|
|
`)
|
|
params = append(params, fdate, tdate)
|
|
}
|
|
|
|
finalQuery := qb.String()
|
|
|
|
utils.Logger.Infow("DeliverySummary SQL generated", "query", finalQuery, "params", params)
|
|
|
|
db.DB.Raw(finalQuery, params...).Scan(&data)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"status": true,
|
|
"message": "Success",
|
|
"details": data,
|
|
})
|
|
}
|
|
|
|
func GetlocationdeliverySummary(c *fiber.Ctx) error {
|
|
tenantIDStr := c.Query("tenantid")
|
|
tenantID, _ := strconv.Atoi(tenantIDStr)
|
|
|
|
var data []models.Ordersummary
|
|
var q1 string
|
|
var params []interface{}
|
|
|
|
q1 = `SELECT b.locationname, a.applocationid, COUNT(*) AS total,
|
|
SUM(CASE WHEN orderstatus = 'created' THEN 1 ELSE 0 END) AS created,
|
|
SUM(CASE WHEN orderstatus = 'pending' THEN 1 ELSE 0 END) AS pending,
|
|
SUM(CASE WHEN orderstatus = 'processing' THEN 1 ELSE 0 END) AS processing,
|
|
SUM(CASE WHEN orderstatus = 'delivered' THEN 1 ELSE 0 END) AS delivered,
|
|
SUM(CASE WHEN orderstatus = 'cancelled' THEN 1 ELSE 0 END) AS cancelled
|
|
FROM orders a
|
|
INNER JOIN app_location b ON a.applocationid = b.applocationid`
|
|
|
|
// Apply tenant filter only if tenantID != 0
|
|
if tenantID != 0 {
|
|
q1 += " WHERE a.tenantid = ?"
|
|
params = append(params, tenantID)
|
|
}
|
|
|
|
q1 += " GROUP BY a.applocationid, b.locationname"
|
|
|
|
if err := db.DB.Raw(q1, params...).Scan(&data).Error; err != nil {
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusInternalServerError,
|
|
"message": err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
}
|
|
|
|
func GetDeliveryInsight(c *fiber.Ctx) error {
|
|
tenantIDStr := c.Query("tenantid")
|
|
tenantID, _ := strconv.Atoi(tenantIDStr)
|
|
|
|
var locations []models.OrderInsight
|
|
var params []interface{}
|
|
|
|
// Query 1: Get distinct locations
|
|
q1 := `SELECT DISTINCT a.applocationid, b.locationname
|
|
FROM deliveries a
|
|
INNER JOIN app_location b ON a.applocationid = b.applocationid
|
|
WHERE b.status = 'Active'`
|
|
|
|
if tenantID != 0 {
|
|
q1 += " AND a.tenantid = ?"
|
|
params = append(params, tenantID)
|
|
}
|
|
|
|
if err := db.DB.Raw(q1, params...).Scan(&locations).Error; err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
// Query 2: Fetch delivery insights for each location
|
|
q2 := `SELECT
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM a.deliverydate) = 1 THEN 1 ELSE 0 END), 0) AS jan,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM a.deliverydate) = 2 THEN 1 ELSE 0 END), 0) AS feb,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM a.deliverydate) = 3 THEN 1 ELSE 0 END), 0) AS mar,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM a.deliverydate) = 4 THEN 1 ELSE 0 END), 0) AS apr,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM a.deliverydate) = 5 THEN 1 ELSE 0 END), 0) AS may,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM a.deliverydate) = 6 THEN 1 ELSE 0 END), 0) AS jun,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM a.deliverydate) = 7 THEN 1 ELSE 0 END), 0) AS jul,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM a.deliverydate) = 8 THEN 1 ELSE 0 END), 0) AS aug,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM a.deliverydate) = 9 THEN 1 ELSE 0 END), 0) AS sep,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM a.deliverydate) = 10 THEN 1 ELSE 0 END), 0) AS oct,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM a.deliverydate) = 11 THEN 1 ELSE 0 END), 0) AS nov,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM a.deliverydate) = 12 THEN 1 ELSE 0 END), 0) AS dece
|
|
FROM deliveries a
|
|
WHERE a.applocationid = ? AND EXTRACT(YEAR FROM a.deliverydate) = EXTRACT(YEAR FROM CURRENT_DATE)`
|
|
|
|
if tenantID != 0 {
|
|
q2 += " AND a.tenantid = ?"
|
|
}
|
|
|
|
// Fetch monthly delivery counts for each location
|
|
for i := range locations {
|
|
var orderMonths models.Ordermonths
|
|
|
|
if tenantID != 0 {
|
|
if err := db.DB.Raw(q2, locations[i].Applocationid, tenantID).Scan(&orderMonths).Error; err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
} else {
|
|
if err := db.DB.Raw(q2, locations[i].Applocationid).Scan(&orderMonths).Error; err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
}
|
|
|
|
locations[i].Ordermonths = &orderMonths
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": locations,
|
|
})
|
|
}
|
|
|
|
func DeliverySummary(c *fiber.Ctx) error {
|
|
|
|
pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
|
|
var data models.DeliverySummary
|
|
|
|
q1 := `SELECT
|
|
COUNT(*) AS deliveries,
|
|
SUM(CASE WHEN orderstatus = 'cancelled' THEN 1 ELSE 0 END) AS cancelled,
|
|
SUM(round(kms, 2)) AS kms,
|
|
SUM(deliveryamt) AS amount
|
|
FROM
|
|
deliveries
|
|
WHERE
|
|
partnerid =?`
|
|
|
|
db.DB.Raw(q1, pid).Find(&data)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
|
|
}
|
|
|
|
func CreateDelivery(c *fiber.Ctx) error {
|
|
|
|
var data models.Deliveries
|
|
|
|
if err := c.BodyParser(&data); err != nil {
|
|
return err
|
|
}
|
|
|
|
err := domain.CreateDelivery(data)
|
|
if err != nil {
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": err,
|
|
"status": false,
|
|
})
|
|
|
|
} else {
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusCreated,
|
|
"message": "Success",
|
|
"status": true,
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func CreateDeliveries(c *fiber.Ctx) error {
|
|
|
|
var data []models.Deliveries
|
|
|
|
if err := c.BodyParser(&data); err != nil {
|
|
return err
|
|
}
|
|
|
|
err := domain.CreateDeliveries(data)
|
|
|
|
if err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusCreated,
|
|
"message": "Success",
|
|
"status": true,
|
|
})
|
|
|
|
}
|
|
|
|
func CreateDeliveriesV2(c *fiber.Ctx) error {
|
|
|
|
var data []models.Deliveries
|
|
|
|
if err := c.BodyParser(&data); err != nil {
|
|
return c.Status(400).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 400,
|
|
"message": "Invalid JSON body",
|
|
})
|
|
}
|
|
|
|
utils.Logger.Infow("CreateDeliveriesV2 Call", "records", len(data))
|
|
|
|
ids, err := domain.CreateDeliveriesV2(data)
|
|
if err != nil {
|
|
return c.Status(409).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 409,
|
|
"message": err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 201,
|
|
"message": "Deliveries created successfully",
|
|
"deliveryids": ids,
|
|
})
|
|
}
|
|
|
|
func UpdateDelivery(c *fiber.Ctx) error {
|
|
|
|
var data models.UpdateDeliveryStatus
|
|
|
|
if err := c.BodyParser(&data); err != nil {
|
|
return err
|
|
}
|
|
|
|
err := domain.UpdateDelivery(data)
|
|
|
|
if err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusCreated,
|
|
"message": "Success",
|
|
"status": true,
|
|
})
|
|
|
|
}
|
|
|
|
func GetDeliveryQueues(c *fiber.Ctx) error {
|
|
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
|
|
result := domain.GetDeliveryQueues(uid, fdate, tdate)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
}
|
|
|
|
func GetDeliveryQueuesV1(c *fiber.Ctx) error {
|
|
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
|
|
result := domain.GetDeliveryQueuesV1(uid, fdate, tdate)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
}
|
|
|
|
func GetDeliveryQueuesPicked(c *fiber.Ctx) error {
|
|
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
|
|
result := domain.GetDeliveryQueuesPicked(uid, fdate, tdate)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
|
|
}
|
|
|
|
func GetlocationdeliverySummaryDaily(c *fiber.Ctx) error {
|
|
tenantIDStr := c.Query("tenantid")
|
|
tenantID, _ := strconv.Atoi(tenantIDStr)
|
|
|
|
var data []models.Ordersummarylocation
|
|
var q1 string
|
|
var params []interface{}
|
|
|
|
q1 = `
|
|
SELECT
|
|
b.locationid,
|
|
b.locationname,
|
|
COALESCE(COUNT(a.orderid), 0) AS total,
|
|
COALESCE(SUM(CASE WHEN a.orderstatus = 'created' THEN 1 ELSE 0 END), 0) AS created,
|
|
COALESCE(SUM(CASE WHEN a.orderstatus = 'pending' THEN 1 ELSE 0 END), 0) AS pending,
|
|
COALESCE(SUM(CASE WHEN a.orderstatus = 'processing' THEN 1 ELSE 0 END), 0) AS processing,
|
|
COALESCE(SUM(CASE WHEN a.orderstatus = 'delivered' THEN 1 ELSE 0 END), 0) AS delivered,
|
|
COALESCE(SUM(CASE WHEN a.orderstatus = 'cancelled' THEN 1 ELSE 0 END), 0) AS cancelled
|
|
FROM tenantlocations b
|
|
LEFT JOIN orders a ON a.locationid = b.locationid
|
|
`
|
|
|
|
// ✅ Apply tenant filter on tenantlocations (not orders only)
|
|
if tenantID != 0 {
|
|
q1 += " WHERE b.tenantid = ?"
|
|
params = append(params, tenantID)
|
|
}
|
|
|
|
q1 += " GROUP BY b.locationid, b.locationname"
|
|
|
|
if err := db.DB.Raw(q1, params...).Scan(&data).Error; err != nil {
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusInternalServerError,
|
|
"message": err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
}
|
|
|
|
func GetDeliveryInsightDaily(c *fiber.Ctx) error {
|
|
tenantIDStr := c.Query("tenantid")
|
|
tenantID, _ := strconv.Atoi(tenantIDStr)
|
|
|
|
var locations []models.OrderInsightv1
|
|
var params []interface{}
|
|
|
|
q1 := `SELECT DISTINCT l.locationid, l.locationname
|
|
FROM tenantlocations l
|
|
LEFT JOIN deliveries d ON l.locationid = d.locationid
|
|
WHERE l.status = 'Active'`
|
|
|
|
if tenantID != 0 {
|
|
q1 += " AND l.tenantid = ?"
|
|
params = append(params, tenantID)
|
|
}
|
|
|
|
if err := db.DB.Raw(q1, params...).Scan(&locations).Error; err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
q2 := `SELECT
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM d.deliverydate) = 1 THEN 1 ELSE 0 END), 0) AS jan,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM d.deliverydate) = 2 THEN 1 ELSE 0 END), 0) AS feb,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM d.deliverydate) = 3 THEN 1 ELSE 0 END), 0) AS mar,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM d.deliverydate) = 4 THEN 1 ELSE 0 END), 0) AS apr,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM d.deliverydate) = 5 THEN 1 ELSE 0 END), 0) AS may,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM d.deliverydate) = 6 THEN 1 ELSE 0 END), 0) AS jun,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM d.deliverydate) = 7 THEN 1 ELSE 0 END), 0) AS jul,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM d.deliverydate) = 8 THEN 1 ELSE 0 END), 0) AS aug,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM d.deliverydate) = 9 THEN 1 ELSE 0 END), 0) AS sep,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM d.deliverydate) = 10 THEN 1 ELSE 0 END), 0) AS oct,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM d.deliverydate) = 11 THEN 1 ELSE 0 END), 0) AS nov,
|
|
COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM d.deliverydate) = 12 THEN 1 ELSE 0 END), 0) AS dece
|
|
FROM deliveries d
|
|
WHERE d.locationid = ? AND EXTRACT(YEAR FROM d.deliverydate) = EXTRACT(YEAR FROM CURRENT_DATE)`
|
|
|
|
if tenantID != 0 {
|
|
q2 += " AND d.tenantid = ?"
|
|
}
|
|
|
|
for i := range locations {
|
|
var orderMonths models.Ordermonths
|
|
|
|
if tenantID != 0 {
|
|
if err := db.DB.Raw(q2, locations[i].Locationid, tenantID).Scan(&orderMonths).Error; err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
} else {
|
|
if err := db.DB.Raw(q2, locations[i].Locationid).Scan(&orderMonths).Error; err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
}
|
|
|
|
locations[i].Ordermonths = &orderMonths
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": locations,
|
|
})
|
|
}
|
|
|
|
func PublishLogv1(c *fiber.Ctx) error {
|
|
var data []models.Deliverylogs
|
|
|
|
if err := c.BodyParser(&data); err != nil {
|
|
return c.Status(http.StatusBadRequest).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusBadRequest,
|
|
"message": "Invalid JSON body",
|
|
})
|
|
}
|
|
|
|
err := domain.PublishLogv1(data)
|
|
if err != nil {
|
|
return c.Status(http.StatusConflict).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": true,
|
|
"code": http.StatusOK,
|
|
"message": "Successfully saved logs to Redis",
|
|
})
|
|
}
|
|
|
|
func GetDeliverylogsv1(c *fiber.Ctx) error {
|
|
did, _ := strconv.Atoi(c.Query("deliveryid"))
|
|
|
|
result, err := domain.GetDeliverylogsv1(did)
|
|
if err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusConflict,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
"details": []models.Deliverylogs{},
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
}
|
|
|
|
func GetDeliveryLogsv1(c *fiber.Ctx) error {
|
|
deliveryID := c.Query("deliveryid")
|
|
if deliveryID == "" {
|
|
return c.Status(http.StatusBadRequest).JSON(fiber.Map{
|
|
"code": http.StatusBadRequest,
|
|
"message": "deliveryid is required",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
logs, err := domain.GetDeliveryLogsv1(deliveryID)
|
|
if err != nil {
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"code": http.StatusInternalServerError,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": 200,
|
|
"details": logs,
|
|
"status": true,
|
|
})
|
|
}
|
|
|
|
func GetRiderByDelivery(c *fiber.Ctx) error {
|
|
|
|
fromdate := strings.TrimSpace(c.Query("fromdate"))
|
|
todate := strings.TrimSpace(c.Query("todate"))
|
|
keyword := strings.TrimSpace(c.Query("keyword"))
|
|
|
|
if fromdate == "" || todate == "" {
|
|
return c.Status(400).JSON(fiber.Map{
|
|
"code": 400,
|
|
"status": false,
|
|
"message": "fromdate and todate are required",
|
|
})
|
|
}
|
|
|
|
applocationidStr := strings.TrimSpace(c.Query("applocationid"))
|
|
tenantidStr := strings.TrimSpace(c.Query("tenantid"))
|
|
locationidStr := strings.TrimSpace(c.Query("locationid"))
|
|
|
|
applocationid, _ := strconv.Atoi(applocationidStr)
|
|
tenantid, _ := strconv.Atoi(tenantidStr)
|
|
locationid, _ := strconv.Atoi(locationidStr)
|
|
|
|
var users []models.User
|
|
var params []interface{}
|
|
|
|
query := `
|
|
SELECT b.userid,b.authname,b.firstname,b.lastname,b.password,b.email,b.dialcode,b.contactno,b.configid,b.authmode,b.roleid,b.pin,b.deviceid,b.devicetype,b.userfcmtoken,
|
|
b.address,b.suburb,b.city,b.state,b.postcode,b.partnerid,a.tenantid,a.locationid,a.applocationid,b.status,b.shiftid,b.hashsalt
|
|
FROM deliveries a
|
|
LEFT JOIN app_users b ON a.userid = b.userid
|
|
WHERE a.deliverydate::date BETWEEN ?::date AND ?::date
|
|
`
|
|
params = append(params, fromdate, todate)
|
|
|
|
if tenantid != 0 {
|
|
query += " AND a.tenantid = ?"
|
|
params = append(params, tenantid)
|
|
}
|
|
if locationid != 0 {
|
|
query += " AND a.locationid = ?"
|
|
params = append(params, locationid)
|
|
}
|
|
if applocationid != 0 {
|
|
query += " AND a.applocationid = ?"
|
|
params = append(params, applocationid)
|
|
}
|
|
|
|
if keyword != "" {
|
|
k := "%" + strings.ToLower(keyword) + "%"
|
|
query += `
|
|
AND (
|
|
LOWER(b.firstname) LIKE ? OR
|
|
LOWER(b.lastname) LIKE ? OR
|
|
LOWER(b.contactno) LIKE ?
|
|
)
|
|
`
|
|
params = append(params, k, k, k)
|
|
}
|
|
|
|
query += " GROUP BY b.userid ORDER BY b.userid DESC"
|
|
|
|
if err := db.DB.Raw(query, params...).Scan(&users).Error; err != nil {
|
|
return c.Status(500).JSON(fiber.Map{
|
|
"code": 500,
|
|
"status": false,
|
|
"message": "Database error: " + err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": 200,
|
|
"status": true,
|
|
"details": users,
|
|
})
|
|
}
|
|
|
|
func GetLastDeliveryByContact(c *fiber.Ctx) error {
|
|
deliverycontactno := c.Query("deliverycontactno")
|
|
fromdate := c.Query("fromdate")
|
|
todate := c.Query("todate")
|
|
|
|
var data []models.Deliveries
|
|
var query string
|
|
var args []interface{}
|
|
|
|
dateCondition := ""
|
|
if fromdate != "" && todate != "" {
|
|
dateCondition = " AND deliverydate::date BETWEEN ?::date AND ?::date "
|
|
args = append(args, fromdate, todate)
|
|
} else if fromdate != "" {
|
|
dateCondition = " AND deliverydate::date >= ?::date "
|
|
args = append(args, fromdate)
|
|
} else if todate != "" {
|
|
dateCondition = " AND deliverydate::date <= ?::date "
|
|
args = append(args, todate)
|
|
}
|
|
|
|
if deliverycontactno == "" {
|
|
|
|
query = `
|
|
SELECT d.*
|
|
FROM deliveries d
|
|
INNER JOIN (
|
|
SELECT deliverycontactno, MAX(deliveryid) AS maxid
|
|
FROM deliveries
|
|
WHERE 1=1 ` + dateCondition + `
|
|
GROUP BY deliverycontactno
|
|
) t ON d.deliveryid = t.maxid
|
|
ORDER BY d.deliveryid DESC;
|
|
`
|
|
} else {
|
|
|
|
query = `
|
|
SELECT *
|
|
FROM deliveries
|
|
WHERE deliverycontactno = ? ` + dateCondition + `
|
|
ORDER BY deliveryid DESC
|
|
LIMIT 1;
|
|
`
|
|
|
|
args = append([]interface{}{deliverycontactno}, args...)
|
|
}
|
|
|
|
if err := db.DB.Raw(query, args...).Scan(&data).Error; err != nil {
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
|
|
"code": 500,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
return c.Status(200).JSON(fiber.Map{
|
|
"code": 200,
|
|
"message": "Success",
|
|
"details": data,
|
|
"status": true,
|
|
})
|
|
}
|
|
|
|
func GetUserReportSummary(c *fiber.Ctx) error {
|
|
|
|
tid, _ := strconv.Atoi(c.Query("tenantid"))
|
|
// pid, _ := strconv.Atoi(c.Query("partnerid"))
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
// aid, _ := strconv.Atoi(c.Query("applocationid"))
|
|
fdate := c.Query("fromdate")
|
|
tdate := c.Query("todate")
|
|
|
|
var data []models.UserReportSummary
|
|
var q1 string
|
|
|
|
var params []interface{}
|
|
q1 = reports
|
|
|
|
if tid != 0 {
|
|
q1 += " WHERE a.tenantid = ?"
|
|
params = append(params, tid)
|
|
} else if uid != 0 {
|
|
q1 += " WHERE c.userid = ?"
|
|
params = append(params, uid)
|
|
} else {
|
|
q1 += " WHERE 1=1"
|
|
}
|
|
|
|
if fdate != "" && tdate != "" {
|
|
q1 += " AND a.orderdate::date BETWEEN ?::date AND ?::date"
|
|
params = append(params, fdate, tdate)
|
|
}
|
|
|
|
q1 += ` GROUP BY
|
|
c.userid, e.firstname, e.lastname, e.contactno,
|
|
b.tenantid, b.tenantname`
|
|
|
|
utils.Logger.Debugw("RiderLocationReportSummary SQL generated", "query", q1)
|
|
|
|
db.DB.Raw(q1, params...).Scan(&data)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
}
|
|
|
|
func GetUserDeliveryLogs(c *fiber.Ctx) error {
|
|
userid, err := strconv.Atoi(c.Query("userid"))
|
|
if err != nil || userid == 0 {
|
|
return c.Status(400).JSON(fiber.Map{
|
|
"code": 400,
|
|
"message": "Invalid userid",
|
|
"status": false,
|
|
"details": []models.Deliverylogs{},
|
|
})
|
|
}
|
|
|
|
fromdate := strings.TrimSpace(c.Query("fromdate"))
|
|
todate := strings.TrimSpace(c.Query("todate"))
|
|
|
|
result, err := domain.GetUserDeliveryLogs(userid, fromdate, todate)
|
|
if err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"code": 409,
|
|
"message": err.Error(),
|
|
"status": false,
|
|
"details": []models.Deliverylogs{},
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": 200,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": result,
|
|
})
|
|
}
|