apksel-dev/apskel-pos-backend
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
aditya.siregar
2025-04-10 11:21:08 +07:00
parent c642c5c61b
commit 09c9a4d59d
30 changed files with 1797 additions and 758 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/repository/In_progress_orde_repo.go
+3 -4
View File
@@ -2,7 +2,6 @@ package repository
import (
"enaklo-pos-be/internal/common/mycontext"
"enaklo-pos-be/internal/constants"
"enaklo-pos-be/internal/entity"
"enaklo-pos-be/internal/repository/models"
"github.com/pkg/errors"
@@ -152,7 +151,7 @@ func (r *inprogressOrderRepository) GetListByPartnerID(ctx mycontext.Context, pa
func (r *inprogressOrderRepository) toInProgressOrderDBModel(order *entity.InProgressOrder) models.InProgressOrderDB {
now := time2.Now()
return models.InProgressOrderDB{
ID: constants.GenerateUUID(),
ID: order.ID,
PartnerID: order.PartnerID,
CustomerID: order.CustomerID,
CustomerName: order.CustomerName,
@@ -207,7 +206,7 @@ func (r *inprogressOrderRepository) toOrderInquiryDBModel(inquiry *entity.OrderI
CustomerID: &inquiry.CustomerID,
Status: inquiry.Status,
Amount: inquiry.Amount,
Fee: inquiry.Fee,
Tax: inquiry.Tax,
Total: inquiry.Total,
PaymentType: inquiry.PaymentType,
Source: inquiry.Source,
@@ -230,7 +229,7 @@ func (r *inprogressOrderRepository) toDomainOrderInquiryModel(dbModel *models.Or
PartnerID: dbModel.PartnerID,
Status: dbModel.Status,
Amount: dbModel.Amount,
Fee: dbModel.Fee,
Tax: dbModel.Tax,
Total: dbModel.Total,
PaymentType: dbModel.PaymentType,
Source: dbModel.Source,
internal/repository/models/order.go
+22 -15
View File
@@ -5,20 +5,24 @@ import (
)
type OrderDB struct {
ID int64 `gorm:"primaryKey;column:id"`
PartnerID int64 `gorm:"column:partner_id"`
CustomerID *int64 `gorm:"column:customer_id"`
InquiryID *string `gorm:"column:inquiry_id"`
Status string `gorm:"column:status"`
Amount float64 `gorm:"column:amount"`
Fee float64 `gorm:"column:fee"`
Total float64 `gorm:"column:total"`
PaymentType string `gorm:"column:payment_type"`
Source string `gorm:"column:source"`
CreatedBy int64 `gorm:"column:created_by"`
CreatedAt time.Time `gorm:"column:created_at"`
UpdatedAt time.Time `gorm:"column:updated_at"`
OrderItems []OrderItemDB `gorm:"foreignKey:OrderID"`
ID int64 `gorm:"primaryKey;column:id"`
PartnerID int64 `gorm:"column:partner_id"`
CustomerID *int64 `gorm:"column:customer_id"`
InquiryID *string `gorm:"column:inquiry_id"`
Status string `gorm:"column:status"`
Amount float64 `gorm:"column:amount"`
Tax float64 `gorm:"column:tax"`
Total float64 `gorm:"column:total"`
PaymentType string `gorm:"column:payment_type"`
Source string `gorm:"column:source"`
CreatedBy int64 `gorm:"column:created_by"`
CreatedAt time.Time `gorm:"column:created_at"`
UpdatedAt time.Time `gorm:"column:updated_at"`
OrderItems []OrderItemDB `gorm:"foreignKey:OrderID"`
OrderType string `gorm:"column:order_type"`
TableNumber string `gorm:"column:table_number"`
PaymentProvider string `gorm:"column:payment_provider"`
CustomerName string `gorm:"column:customer_name"`
}
func (OrderDB) TableName() string {
@@ -29,11 +33,13 @@ type OrderItemDB struct {
ID int64 `gorm:"primaryKey;column:order_item_id"`
OrderID int64 `gorm:"column:order_id"`
ItemID int64 `gorm:"column:item_id"`
ItemName string `gorm:"column:item_name"`
ItemType string `gorm:"column:item_type"`
Price float64 `gorm:"column:price"`
Quantity int `gorm:"column:quantity"`
CreatedBy int64 `gorm:"column:created_by"`
CreatedAt time.Time `gorm:"column:created_at"`
Product ProductDB `gorm:"foreignKey:ItemID;references:ID"`
}
func (OrderItemDB) TableName() string {
@@ -49,7 +55,7 @@ type OrderInquiryDB struct {
CustomerPhoneNumber string `gorm:"column:customer_phone_number"`
Status string `gorm:"column:status"`
Amount float64 `gorm:"column:amount"`
Fee float64 `gorm:"column:fee"`
Tax float64 `gorm:"column:tax"`
Total float64 `gorm:"column:total"`
PaymentType string `gorm:"column:payment_type"`
Source string `gorm:"column:source"`
@@ -72,6 +78,7 @@ type InquiryItemDB struct {
InquiryID string `gorm:"column:inquiry_id"`
ItemID int64 `gorm:"column:item_id"`
ItemType string `gorm:"column:item_type"`
ItemName string `gorm:"column:item_name"`
Price float64 `gorm:"column:price"`
Quantity int `gorm:"column:quantity"`
CreatedBy int64 `gorm:"column:created_by"`
internal/repository/models/partner_setting.go
+53
View File
@@ -0,0 +1,53 @@
package models
import (
"time"
)
type PartnerSettingsDB struct {
PartnerID int64 `gorm:"primaryKey;column:partner_id"`
TaxEnabled bool `gorm:"column:tax_enabled;default:false"`
TaxPercentage float64 `gorm:"column:tax_percentage;default:10.00"`
InvoicePrefix string `gorm:"column:invoice_prefix;default:INV"`
BusinessHours string `gorm:"column:business_hours;type:json"` // JSON string
LogoURL string `gorm:"column:logo_url"`
ThemeColor string `gorm:"column:theme_color;default:#000000"`
ReceiptFooterText string `gorm:"column:receipt_footer_text;type:text"`
ReceiptHeaderText string `gorm:"column:receipt_header_text;type:text"`
CreatedAt time.Time `gorm:"column:created_at;default:CURRENT_TIMESTAMP"`
UpdatedAt time.Time `gorm:"column:updated_at;default:CURRENT_TIMESTAMP"`
}
func (PartnerSettingsDB) TableName() string {
return "partner_settings"
}
type PartnerPaymentMethodDB struct {
ID int64 `gorm:"primaryKey;column:id;autoIncrement"`
PartnerID int64 `gorm:"column:partner_id;index:idx_partner_payment"`
PaymentMethod string `gorm:"column:payment_method;index:idx_partner_payment"`
IsEnabled bool `gorm:"column:is_enabled;default:true"`
DisplayName string `gorm:"column:display_name"`
DisplayOrder int `gorm:"column:display_order;default:0"`
AdditionalInfo string `gorm:"column:additional_info;type:json"` // JSON string
CreatedAt time.Time `gorm:"column:created_at;default:CURRENT_TIMESTAMP"`
UpdatedAt time.Time `gorm:"column:updated_at;default:CURRENT_TIMESTAMP"`
}
func (PartnerPaymentMethodDB) TableName() string {
return "partner_payment_methods"
}
type PartnerFeatureFlagDB struct {
ID int64 `gorm:"primaryKey;column:id;autoIncrement"`
PartnerID int64 `gorm:"column:partner_id;index:idx_partner_feature"`
FeatureKey string `gorm:"column:feature_key;index:idx_partner_feature"`
IsEnabled bool `gorm:"column:is_enabled;default:true"`
Config string `gorm:"column:config;type:json"` // JSON string
CreatedAt time.Time `gorm:"column:created_at;default:CURRENT_TIMESTAMP"`
UpdatedAt time.Time `gorm:"column:updated_at;default:CURRENT_TIMESTAMP"`
}
func (PartnerFeatureFlagDB) TableName() string {
return "partner_feature_flags"
}
internal/repository/orde_repo.go
+562 -43
View File
@@ -17,6 +17,26 @@ type OrderRepository interface {
CreateInquiry(ctx mycontext.Context, inquiry *entity.OrderInquiry) (*entity.OrderInquiry, error)
FindInquiryByID(ctx mycontext.Context, id string) (*entity.OrderInquiry, error)
UpdateInquiryStatus(ctx mycontext.Context, id string, status string) error
GetOrderHistoryByPartnerID(ctx mycontext.Context, partnerID int64, req entity.SearchRequest) ([]*entity.Order, int64, error)
CreateOrUpdate(ctx mycontext.Context, order *entity.Order) (*entity.Order, error)
GetListByPartnerID(ctx mycontext.Context, partnerID int64, limit, offset int, status string) ([]*entity.Order, error)
GetOrderPaymentMethodBreakdown(
ctx mycontext.Context,
partnerID int64,
req entity.SearchRequest,
) ([]entity.PaymentMethodBreakdown, error)
GetRevenueOverview(
ctx mycontext.Context,
req entity.RevenueOverviewRequest,
) ([]entity.RevenueOverviewItem, error)
GetSalesByCategory(
ctx mycontext.Context,
req entity.SalesByCategoryRequest,
) ([]entity.SalesByCategoryItem, error)
GetPopularProducts(
ctx mycontext.Context,
req entity.PopularProductsRequest,
) ([]entity.PopularProductItem, error)
}
type orderRepository struct {
@@ -61,13 +81,13 @@ func (r *orderRepository) Create(ctx mycontext.Context, order *entity.Order) (*e
item.ID = itemDB.ID
}
if order.InProgressOrderID != "" {
if err := tx.Where("in_progress_order_id = ?", order.InProgressOrderID).Delete(&models.InProgressOrderItemDB{}).Error; err != nil {
if order.InProgressOrderID != 0 {
if err := tx.Where("order_id = ?", order.InProgressOrderID).Delete(&models.OrderItemDB{}).Error; err != nil {
tx.Rollback()
return nil, errors.Wrap(err, "failed to delete in-progress order items")
}
if err := tx.Where("id = ?", order.InProgressOrderID).Delete(&models.InProgressOrderDB{}).Error; err != nil {
if err := tx.Where("id = ?", order.InProgressOrderID).Delete(&models.OrderDB{}).Error; err != nil {
tx.Rollback()
return nil, errors.Wrap(err, "failed to delete in-progress order")
}
@@ -109,6 +129,7 @@ func (r *orderRepository) CreateInquiry(ctx mycontext.Context, inquiry *entity.O
InquiryID: inquiryDB.ID,
ItemID: item.ItemID,
ItemType: item.ItemType,
ItemName: item.ItemName,
Price: item.Price,
Quantity: item.Quantity,
CreatedBy: item.CreatedBy,
@@ -162,6 +183,7 @@ func (r *orderRepository) FindInquiryByID(ctx mycontext.Context, id string) (*en
orderItems = append(orderItems, entity.OrderItem{
ItemID: itemDB.ItemID,
ItemType: itemDB.ItemType,
ItemName: itemDB.ItemName,
Price: itemDB.Price,
Quantity: itemDB.Quantity,
CreatedBy: itemDB.CreatedBy,
@@ -196,38 +218,46 @@ func (r *orderRepository) UpdateInquiryStatus(ctx mycontext.Context, id string,
func (r *orderRepository) toOrderDBModel(order *entity.Order) models.OrderDB {
return models.OrderDB{
ID: order.ID,
PartnerID: order.PartnerID,
CustomerID: order.CustomerID,
InquiryID: order.InquiryID,
Status: order.Status,
Amount: order.Amount,
Fee: order.Fee,
Total: order.Total,
PaymentType: order.PaymentType,
Source: order.Source,
CreatedBy: order.CreatedBy,
CreatedAt: order.CreatedAt,
UpdatedAt: order.UpdatedAt,
ID: order.ID,
PartnerID: order.PartnerID,
CustomerID: order.CustomerID,
InquiryID: order.InquiryID,
Status: order.Status,
Amount: order.Amount,
Tax: order.Tax,
Total: order.Total,
PaymentType: order.PaymentType,
Source: order.Source,
CreatedBy: order.CreatedBy,
CreatedAt: order.CreatedAt,
UpdatedAt: order.UpdatedAt,
OrderType: order.OrderType,
TableNumber: order.TableNumber,
PaymentProvider: order.PaymentProvider,
CustomerName: order.CustomerName,
}
}
func (r *orderRepository) toDomainOrderModel(dbModel *models.OrderDB) *entity.Order {
return &entity.Order{
ID: dbModel.ID,
PartnerID: dbModel.PartnerID,
CustomerID: dbModel.CustomerID,
InquiryID: dbModel.InquiryID,
Status: dbModel.Status,
Amount: dbModel.Amount,
Fee: dbModel.Fee,
Total: dbModel.Total,
PaymentType: dbModel.PaymentType,
Source: dbModel.Source,
CreatedBy: dbModel.CreatedBy,
CreatedAt: dbModel.CreatedAt,
UpdatedAt: dbModel.UpdatedAt,
OrderItems: []entity.OrderItem{},
ID: dbModel.ID,
PartnerID: dbModel.PartnerID,
CustomerID: dbModel.CustomerID,
InquiryID: dbModel.InquiryID,
Status: dbModel.Status,
Amount: dbModel.Amount,
Tax: dbModel.Tax,
Total: dbModel.Total,
PaymentType: dbModel.PaymentType,
Source: dbModel.Source,
CreatedBy: dbModel.CreatedBy,
CreatedAt: dbModel.CreatedAt,
UpdatedAt: dbModel.UpdatedAt,
OrderItems: []entity.OrderItem{},
CustomerName: dbModel.CustomerName,
TableNumber: dbModel.TableNumber,
OrderType: dbModel.OrderType,
PaymentProvider: dbModel.PaymentProvider,
}
}
@@ -237,6 +267,7 @@ func (r *orderRepository) toOrderItemDBModel(item *entity.OrderItem) models.Orde
OrderID: item.OrderID,
ItemID: item.ItemID,
ItemType: item.ItemType,
ItemName: item.ItemName,
Price: item.Price,
Quantity: item.Quantity,
CreatedBy: item.CreatedBy,
@@ -254,6 +285,7 @@ func (r *orderRepository) toDomainOrderItemModel(dbModel *models.OrderItemDB) *e
Quantity: dbModel.Quantity,
CreatedBy: dbModel.CreatedBy,
CreatedAt: dbModel.CreatedAt,
ItemName: dbModel.ItemName,
}
}
@@ -264,7 +296,7 @@ func (r *orderRepository) toOrderInquiryDBModel(inquiry *entity.OrderInquiry) mo
CustomerID: &inquiry.CustomerID,
Status: inquiry.Status,
Amount: inquiry.Amount,
Fee: inquiry.Fee,
Tax: inquiry.Tax,
Total: inquiry.Total,
PaymentType: inquiry.PaymentType,
Source: inquiry.Source,
@@ -283,18 +315,22 @@ func (r *orderRepository) toOrderInquiryDBModel(inquiry *entity.OrderInquiry) mo
func (r *orderRepository) toDomainOrderInquiryModel(dbModel *models.OrderInquiryDB) *entity.OrderInquiry {
inquiry := &entity.OrderInquiry{
ID: dbModel.ID,
PartnerID: dbModel.PartnerID,
Status: dbModel.Status,
Amount: dbModel.Amount,
Fee: dbModel.Fee,
Total: dbModel.Total,
PaymentType: dbModel.PaymentType,
Source: dbModel.Source,
CreatedBy: dbModel.CreatedBy,
CreatedAt: dbModel.CreatedAt,
ExpiresAt: dbModel.ExpiresAt,
OrderItems: []entity.OrderItem{},
ID: dbModel.ID,
PartnerID: dbModel.PartnerID,
Status: dbModel.Status,
Amount: dbModel.Amount,
Tax: dbModel.Tax,
Total: dbModel.Total,
PaymentType: dbModel.PaymentType,
Source: dbModel.Source,
CreatedBy: dbModel.CreatedBy,
CreatedAt: dbModel.CreatedAt,
ExpiresAt: dbModel.ExpiresAt,
OrderItems: []entity.OrderItem{},
OrderType: dbModel.OrderType,
CustomerName: dbModel.CustomerName,
PaymentProvider: dbModel.PaymentProvider,
TableNumber: dbModel.TableNumber,
}
if dbModel.CustomerID != nil {
@@ -305,3 +341,486 @@ func (r *orderRepository) toDomainOrderInquiryModel(dbModel *models.OrderInquiry
return inquiry
}
func (r *orderRepository) GetOrderHistoryByPartnerID(ctx mycontext.Context, partnerID int64, req entity.SearchRequest) ([]*entity.Order, int64, error) {
var ordersDB []models.OrderDB
var totalCount int64
// Build the base query
baseQuery := r.db.Model(&models.OrderDB{}).Where("partner_id = ?", partnerID)
// Apply filters to the base query
if req.Status != "" {
baseQuery = baseQuery.Where("status = ?", req.Status)
}
if !req.Start.IsZero() {
baseQuery = baseQuery.Where("created_at >= ?", req.Start)
}
if !req.End.IsZero() {
baseQuery = baseQuery.Where("created_at <= ?", req.End)
}
// Get total count with the current filters before pagination
if err := baseQuery.Count(&totalCount).Error; err != nil {
return nil, 0, errors.Wrap(err, "failed to count total orders")
}
// Clone the query for fetching the actual data with pagination
query := baseQuery.Session(&gorm.Session{})
// Add ordering and pagination
query = query.Order("created_at DESC")
if req.Limit > 0 {
query = query.Limit(req.Limit)
}
if req.Offset > 0 {
query = query.Offset(req.Offset)
}
// Execute the query with preloading
if err := query.Preload("OrderItems").Find(&ordersDB).Error; err != nil {
return nil, 0, errors.Wrap(err, "failed to find order history by partner ID")
}
// Map to domain models
orders := make([]*entity.Order, 0, len(ordersDB))
for _, orderDB := range ordersDB {
order := r.toDomainOrderModel(&orderDB)
order.OrderItems = make([]entity.OrderItem, 0, len(orderDB.OrderItems))
for _, itemDB := range orderDB.OrderItems {
item := r.toDomainOrderItemModel(&itemDB)
order.OrderItems = append(order.OrderItems, *item)
}
orders = append(orders, order)
}
return orders, totalCount, nil
}
func (r *orderRepository) CreateOrUpdate(ctx mycontext.Context, order *entity.Order) (*entity.Order, error) {
isUpdate := order.ID != 0
tx := r.db.Begin()
if tx.Error != nil {
return nil, errors.Wrap(tx.Error, "failed to begin transaction")
}
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
orderDB := r.toInProgressOrderDBModel(order)
if isUpdate {
var existingOrder models.OrderDB
if err := tx.First(&existingOrder, order.ID).Error; err != nil {
tx.Rollback()
return nil, errors.Wrap(err, "order not found for update")
}
if err := tx.Model(&orderDB).Updates(orderDB).Error; err != nil {
tx.Rollback()
return nil, errors.Wrap(err, "failed to update order")
}
if err := tx.Where("order_id = ?", order.ID).Delete(&models.OrderItemDB{}).Error; err != nil {
tx.Rollback()
return nil, errors.Wrap(err, "failed to delete existing order items")
}
} else {
if err := tx.Create(&orderDB).Error; err != nil {
tx.Rollback()
return nil, errors.Wrap(err, "failed to insert order")
}
order.ID = orderDB.ID
}
var itemIDs []int64
for i := range order.OrderItems {
itemIDs = append(itemIDs, order.OrderItems[i].ItemID)
}
var products []models.ProductDB
if len(itemIDs) > 0 {
if err := tx.Where("id IN ?", itemIDs).Find(&products).Error; err != nil {
tx.Rollback()
return nil, errors.Wrap(err, "failed to fetch products")
}
}
productMap := make(map[int64]models.ProductDB)
for _, product := range products {
productMap[product.ID] = product
}
for i := range order.OrderItems {
item := &order.OrderItems[i]
item.OrderID = orderDB.ID
itemDB := r.toOrderItemDBModel(item)
if err := tx.Create(&itemDB).Error; err != nil {
tx.Rollback()
return nil, errors.Wrap(err, "failed to insert order item")
}
item.ID = itemDB.ID
if product, exists := productMap[item.ItemID]; exists {
item.Product = r.toDomainProductModel(&product)
}
}
if err := tx.Commit().Error; err != nil {
return nil, errors.Wrap(err, "failed to commit transaction")
}
return order, nil
}
func (r *orderRepository) toInProgressOrderDBModel(order *entity.Order) models.OrderDB {
now := time.Now()
return models.OrderDB{
ID: order.ID,
PartnerID: order.PartnerID,
CustomerID: order.CustomerID,
CustomerName: order.CustomerName,
PaymentType: order.PaymentType,
PaymentProvider: order.PaymentProvider,
CreatedBy: order.CreatedBy,
CreatedAt: now,
UpdatedAt: now,
TableNumber: order.TableNumber,
OrderType: order.OrderType,
Status: order.Status,
Amount: order.Amount,
Total: order.Total,
Tax: order.Tax,
Source: order.Source,
}
}
func (r *orderRepository) toDomainProductModel(productDB *models.ProductDB) *entity.Product {
if productDB == nil {
return nil
}
return &entity.Product{
ID: productDB.ID,
Name: productDB.Name,
Description: productDB.Description,
Price: productDB.Price,
CreatedAt: productDB.CreatedAt,
UpdatedAt: productDB.UpdatedAt,
Type: productDB.Type,
Image: productDB.Image,
}
}
func (r *orderRepository) GetListByPartnerID(ctx mycontext.Context, partnerID int64, limit, offset int, status string) ([]*entity.Order, error) {
var ordersDB []models.OrderDB
query := r.db.Where("partner_id = ?", partnerID)
if status != "" {
query = query.Where("status = ?", status)
}
query = query.Order("created_at DESC")
if limit > 0 {
query = query.Limit(limit)
}
if offset > 0 {
query = query.Offset(offset)
}
if err := query.Find(&ordersDB).Error; err != nil {
return nil, errors.Wrap(err, "failed to find orders by partner ID")
}
orders := make([]*entity.Order, 0, len(ordersDB))
for _, orderDB := range ordersDB {
order := r.toDomainOrderModel(&orderDB)
var orderItems []models.OrderItemDB
if err := r.db.Where("order_id = ?", orderDB.ID).Find(&orderItems).Error; err != nil {
return nil, errors.Wrap(err, "failed to find order items")
}
order.OrderItems = make([]entity.OrderItem, 0, len(orderItems))
for _, itemDB := range orderItems {
item := r.toDomainOrderItemModel(&itemDB)
orderItem := entity.OrderItem{
ID: item.ID,
ItemID: item.ItemID,
Quantity: item.Quantity,
ItemName: item.ItemName,
}
if itemDB.ItemID > 0 {
var product models.ProductDB
err := r.db.First(&product, itemDB.ItemID).Error
if err == nil {
productDomain := r.toDomainProductModel(&product)
orderItem.Product = productDomain
}
}
order.OrderItems = append(order.OrderItems, orderItem)
}
orders = append(orders, order)
}
return orders, nil
}
func (r *orderRepository) GetOrderPaymentMethodBreakdown(
ctx mycontext.Context,
partnerID int64,
req entity.SearchRequest,
) ([]entity.PaymentMethodBreakdown, error) {
var breakdown []entity.PaymentMethodBreakdown
baseQuery := r.db.Model(&models.OrderDB{}).Where("partner_id = ?", partnerID)
if !req.Start.IsZero() {
baseQuery = baseQuery.Where("created_at >= ?", req.Start)
}
if !req.End.IsZero() {
baseQuery = baseQuery.Where("created_at <= ?", req.End)
}
if req.Status != "" {
baseQuery = baseQuery.Where("status = ?", req.Status)
}
err := baseQuery.Select(
"payment_type, " +
"payment_provider, " +
"COUNT(*) as total_transactions, " +
"SUM(total) as total_amount",
).Group(
"payment_type, payment_provider",
).Order("total_amount DESC").Scan(&breakdown).Error
if err != nil {
return nil, errors.Wrap(err, "failed to get payment method breakdown")
}
return breakdown, nil
}
func (r *orderRepository) GetRevenueOverview(
ctx mycontext.Context,
req entity.RevenueOverviewRequest,
) ([]entity.RevenueOverviewItem, error) {
var overview []entity.RevenueOverviewItem
baseQuery := r.db.Model(&models.OrderDB{}).
Where("partner_id = ?", req.PartnerID).
Where("EXTRACT(YEAR FROM created_at) = ?", req.Year)
if req.Status != "" {
baseQuery = baseQuery.Where("status = ?", req.Status)
}
switch req.Granularity {
case "m": // Monthly
err := baseQuery.Select(
"TO_CHAR(created_at, 'YYYY-MM') as period, " +
"SUM(total) as total_amount, " +
"COUNT(*) as order_count",
).Group("period").
Order("period").
Scan(&overview).Error
if err != nil {
return nil, errors.Wrap(err, "failed to get monthly revenue overview")
}
case "w": // Weekly
err := baseQuery.Select(
"CONCAT(EXTRACT(YEAR FROM created_at), '-W', " +
"LPAD(EXTRACT(WEEK FROM created_at)::text, 2, '0')) as period, " +
"SUM(total) as total_amount, " +
"COUNT(*) as order_count",
).Group("period").
Order("period").
Scan(&overview).Error
if err != nil {
return nil, errors.Wrap(err, "failed to get weekly revenue overview")
}
case "d": // Daily
err := baseQuery.Select(
"TO_CHAR(created_at, 'YYYY-MM-DD') as period, " +
"SUM(total) as total_amount, " +
"COUNT(*) as order_count",
).Group("period").
Order("period").
Scan(&overview).Error
if err != nil {
return nil, errors.Wrap(err, "failed to get daily revenue overview")
}
default:
return nil, errors.New("invalid granularity. Use 'm' (monthly), 'w' (weekly), or 'd' (daily)")
}
return overview, nil
}
func (r *orderRepository) GetSalesByCategory(
ctx mycontext.Context,
req entity.SalesByCategoryRequest,
) ([]entity.SalesByCategoryItem, error) {
var salesByCategory []entity.SalesByCategoryItem
baseQuery := r.db.Model(&models.OrderItemDB{}).
Joins("JOIN orders ON order_items.order_id = orders.id").
Where("orders.partner_id = ?", req.PartnerID)
if req.Status != "" {
baseQuery = baseQuery.Where("orders.status = ?", req.Status)
}
switch req.Period {
case "d": // Daily
baseQuery = baseQuery.Where("DATE(orders.created_at) = CURRENT_DATE")
case "w": // Weekly
baseQuery = baseQuery.Where("DATE_TRUNC('week', orders.created_at) = DATE_TRUNC('week', CURRENT_DATE)")
case "m": // Monthly
baseQuery = baseQuery.Where("DATE_TRUNC('month', orders.created_at) = DATE_TRUNC('month', CURRENT_DATE)")
default:
return nil, errors.New("invalid period. Use 'd' (daily), 'w' (weekly), or 'm' (monthly)")
}
var totalSales float64
err := r.db.Model(&models.OrderItemDB{}).
Joins("JOIN orders ON order_items.order_id = orders.id").
Where("orders.partner_id = ?", req.PartnerID).
Select("COALESCE(SUM(order_items.price * order_items.quantity), 0)").
Scan(&totalSales).Error
if err != nil {
return nil, errors.Wrap(err, "failed to calculate total sales")
}
err = baseQuery.Select(
"order_items.item_type AS category, " +
"COALESCE(SUM(order_items.price * order_items.quantity), 0) AS total_amount, " +
"COALESCE(SUM(order_items.quantity), 0) AS total_quantity",
).
Group("order_items.item_type").
Order("total_amount DESC").
Scan(&salesByCategory).Error
if err != nil {
return nil, errors.Wrap(err, "failed to get sales by category")
}
for i := range salesByCategory {
if totalSales > 0 {
salesByCategory[i].Percentage =
(salesByCategory[i].TotalAmount / totalSales) * 100
}
}
return salesByCategory, nil
}
func (r *orderRepository) GetPopularProducts(
ctx mycontext.Context,
req entity.PopularProductsRequest,
) ([]entity.PopularProductItem, error) {
if req.Limit == 0 {
req.Limit = 10
}
if req.SortBy != "sales" && req.SortBy != "revenue" {
req.SortBy = "sales" // default to sales
}
// Base query
baseQuery := r.db.Model(&models.OrderItemDB{}).
Joins("JOIN orders ON order_items.order_id = orders.id").
Where("orders.partner_id = ?", req.PartnerID)
if req.Status != "" {
baseQuery = baseQuery.Where("orders.status = ?", req.Status)
}
switch req.Period {
case "d": // Daily
baseQuery = baseQuery.Where("DATE(orders.created_at) = CURRENT_DATE")
case "w": // Weekly
baseQuery = baseQuery.Where("DATE_TRUNC('week', orders.created_at) = DATE_TRUNC('week', CURRENT_DATE)")
case "m": // Monthly
baseQuery = baseQuery.Where("DATE_TRUNC('month', orders.created_at) = DATE_TRUNC('month', CURRENT_DATE)")
default:
return nil, errors.New("invalid period. Use 'd' (daily), 'w' (weekly), or 'm' (monthly)")
}
// Calculate total sales/revenue for percentage calculation
var totalSales struct {
TotalAmount float64
TotalQuantity int64
}
err := baseQuery.
Select("COALESCE(SUM(order_items.price * order_items.quantity), 0) as total_amount, " +
"COALESCE(SUM(order_items.quantity), 0) as total_quantity").
Scan(&totalSales).Error
if err != nil {
return nil, errors.Wrap(err, "failed to calculate total sales")
}
// Prepare the query for popular products
var popularProducts []entity.PopularProductItem
orderClause := "total_sales DESC"
if req.SortBy == "revenue" {
orderClause = "total_revenue DESC"
}
err = baseQuery.
Select(
"order_items.item_id AS product_id, " +
"order_items.item_name AS product_name, " +
"order_items.item_type AS category, " +
"COALESCE(SUM(order_items.quantity), 0) AS total_sales, " +
"COALESCE(SUM(order_items.price * order_items.quantity), 0) AS total_revenue, " +
"COALESCE(AVG(order_items.price), 0) AS average_price",
).
Group("order_items.item_id, order_items.item_name, order_items.item_type").
Order(orderClause).
Limit(req.Limit).
Scan(&popularProducts).Error
if err != nil {
return nil, errors.Wrap(err, "failed to get popular products")
}
for i := range popularProducts {
popularProducts[i].Percentage =
(float64(popularProducts[i].TotalSales) / float64(totalSales.TotalQuantity)) * 100
}
return popularProducts, nil
}
internal/repository/partner_settings.go
+225
View File
@@ -0,0 +1,225 @@
package repository
import (
"enaklo-pos-be/internal/common/mycontext"
"enaklo-pos-be/internal/entity"
"enaklo-pos-be/internal/repository/models"
"github.com/pkg/errors"
"gorm.io/gorm"
"time"
)
type PartnerSettingsRepository interface {
GetByPartnerID(ctx mycontext.Context, partnerID int64) (*entity.PartnerSettings, error)
Upsert(ctx mycontext.Context, settings *entity.PartnerSettings) error
GetPaymentMethods(ctx mycontext.Context, partnerID int64) ([]entity.PartnerPaymentMethod, error)
UpsertPaymentMethod(ctx mycontext.Context, method *entity.PartnerPaymentMethod) error
DeletePaymentMethod(ctx mycontext.Context, id int64, partnerID int64) error
UpdatePaymentMethodOrder(ctx mycontext.Context, partnerID int64, methodIDs []int64) error
}
type partnerSettingsRepository struct {
db *gorm.DB
}
func NewPartnerSettingsRepository(db *gorm.DB) PartnerSettingsRepository {
return &partnerSettingsRepository{db: db}
}
func (r *partnerSettingsRepository) GetByPartnerID(ctx mycontext.Context, partnerID int64) (*entity.PartnerSettings, error) {
var settingsDB models.PartnerSettingsDB
err := r.db.Where("partner_id = ?", partnerID).First(&settingsDB).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return &entity.PartnerSettings{
PartnerID: partnerID,
TaxEnabled: true,
TaxPercentage: 10.0,
}, nil
}
return nil, errors.Wrap(err, "failed to get partner settings")
}
return r.toDomainModel(&settingsDB), nil
}
func (r *partnerSettingsRepository) Upsert(ctx mycontext.Context, settings *entity.PartnerSettings) error {
settingsDB := r.toDBModel(settings)
settingsDB.UpdatedAt = time.Now()
// Check if record exists
var count int64
if err := r.db.Model(&models.PartnerSettingsDB{}).Where("partner_id = ?", settings.PartnerID).Count(&count).Error; err != nil {
return errors.Wrap(err, "failed to check partner settings existence")
}
if count > 0 {
// Update existing record
if err := r.db.Model(&models.PartnerSettingsDB{}).Where("partner_id = ?", settings.PartnerID).Updates(settingsDB).Error; err != nil {
return errors.Wrap(err, "failed to update partner settings")
}
} else {
// Create new record
settingsDB.CreatedAt = time.Now()
if err := r.db.Create(&settingsDB).Error; err != nil {
return errors.Wrap(err, "failed to create partner settings")
}
}
return nil
}
func (r *partnerSettingsRepository) GetPaymentMethods(ctx mycontext.Context, partnerID int64) ([]entity.PartnerPaymentMethod, error) {
var methodsDB []models.PartnerPaymentMethodDB
if err := r.db.Where("partner_id = ?", partnerID).Order("display_order").Find(&methodsDB).Error; err != nil {
return nil, errors.Wrap(err, "failed to get partner payment methods")
}
methods := make([]entity.PartnerPaymentMethod, len(methodsDB))
for i, methodDB := range methodsDB {
methods[i] = *r.toDomainPaymentMethodModel(&methodDB)
}
return methods, nil
}
func (r *partnerSettingsRepository) UpsertPaymentMethod(ctx mycontext.Context, method *entity.PartnerPaymentMethod) error {
methodDB := r.toDBPaymentMethodModel(method)
methodDB.UpdatedAt = time.Now()
tx := r.db.Begin()
if tx.Error != nil {
return errors.Wrap(tx.Error, "failed to begin transaction")
}
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
if method.ID > 0 {
// Update existing record
if err := tx.Model(&models.PartnerPaymentMethodDB{}).Where("id = ? AND partner_id = ?", method.ID, method.PartnerID).Updates(methodDB).Error; err != nil {
tx.Rollback()
return errors.Wrap(err, "failed to update payment method")
}
} else {
// Get the next display order if not specified
if method.DisplayOrder == 0 {
var maxOrder int
if err := tx.Model(&models.PartnerPaymentMethodDB{}).Where("partner_id = ?", method.PartnerID).Select("COALESCE(MAX(display_order), 0)").Row().Scan(&maxOrder); err != nil {
tx.Rollback()
return errors.Wrap(err, "failed to get max display order")
}
methodDB.DisplayOrder = maxOrder + 1
}
// Create new record
methodDB.CreatedAt = time.Now()
if err := tx.Create(&methodDB).Error; err != nil {
tx.Rollback()
return errors.Wrap(err, "failed to create payment method")
}
method.ID = methodDB.ID
}
return tx.Commit().Error
}
func (r *partnerSettingsRepository) DeletePaymentMethod(ctx mycontext.Context, id int64, partnerID int64) error {
result := r.db.Where("id = ? AND partner_id = ?", id, partnerID).Delete(&models.PartnerPaymentMethodDB{})
if result.Error != nil {
return errors.Wrap(result.Error, "failed to delete payment method")
}
if result.RowsAffected == 0 {
return errors.New("payment method not found or not authorized")
}
return nil
}
func (r *partnerSettingsRepository) UpdatePaymentMethodOrder(ctx mycontext.Context, partnerID int64, methodIDs []int64) error {
tx := r.db.Begin()
if tx.Error != nil {
return errors.Wrap(tx.Error, "failed to begin transaction")
}
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
for i, id := range methodIDs {
if err := tx.Model(&models.PartnerPaymentMethodDB{}).
Where("id = ? AND partner_id = ?", id, partnerID).
Update("display_order", i+1).Error; err != nil {
tx.Rollback()
return errors.Wrap(err, "failed to update payment method order")
}
}
return tx.Commit().Error
}
func (r *partnerSettingsRepository) toDomainModel(dbModel *models.PartnerSettingsDB) *entity.PartnerSettings {
return &entity.PartnerSettings{
PartnerID: dbModel.PartnerID,
TaxEnabled: dbModel.TaxEnabled,
TaxPercentage: dbModel.TaxPercentage,
InvoicePrefix: dbModel.InvoicePrefix,
BusinessHours: dbModel.BusinessHours,
LogoURL: dbModel.LogoURL,
ThemeColor: dbModel.ThemeColor,
ReceiptFooterText: dbModel.ReceiptFooterText,
ReceiptHeaderText: dbModel.ReceiptHeaderText,
CreatedAt: dbModel.CreatedAt,
UpdatedAt: dbModel.UpdatedAt,
}
}
func (r *partnerSettingsRepository) toDBModel(domainModel *entity.PartnerSettings) models.PartnerSettingsDB {
return models.PartnerSettingsDB{
PartnerID: domainModel.PartnerID,
TaxEnabled: domainModel.TaxEnabled,
TaxPercentage: domainModel.TaxPercentage,
InvoicePrefix: domainModel.InvoicePrefix,
BusinessHours: domainModel.BusinessHours,
LogoURL: domainModel.LogoURL,
ThemeColor: domainModel.ThemeColor,
ReceiptFooterText: domainModel.ReceiptFooterText,
ReceiptHeaderText: domainModel.ReceiptHeaderText,
}
}
func (r *partnerSettingsRepository) toDomainPaymentMethodModel(dbModel *models.PartnerPaymentMethodDB) *entity.PartnerPaymentMethod {
return &entity.PartnerPaymentMethod{
ID: dbModel.ID,
PartnerID: dbModel.PartnerID,
PaymentMethod: dbModel.PaymentMethod,
IsEnabled: dbModel.IsEnabled,
DisplayName: dbModel.DisplayName,
DisplayOrder: dbModel.DisplayOrder,
AdditionalInfo: dbModel.AdditionalInfo,
CreatedAt: dbModel.CreatedAt,
UpdatedAt: dbModel.UpdatedAt,
}
}
func (r *partnerSettingsRepository) toDBPaymentMethodModel(domainModel *entity.PartnerPaymentMethod) models.PartnerPaymentMethodDB {
return models.PartnerPaymentMethodDB{
ID: domainModel.ID,
PartnerID: domainModel.PartnerID,
PaymentMethod: domainModel.PaymentMethod,
IsEnabled: domainModel.IsEnabled,
DisplayName: domainModel.DisplayName,
DisplayOrder: domainModel.DisplayOrder,
AdditionalInfo: domainModel.AdditionalInfo,
}
}
internal/repository/repository.go
+2
View File
@@ -58,6 +58,7 @@ type RepoManagerImpl struct {
ProductRepo ProductRepository
TransactionRepo TransactionRepo
MemberRepository MemberRepository
PartnerSetting PartnerSettingsRepository
}
func NewRepoManagerImpl(db *gorm.DB, cfg *config.Config) *RepoManagerImpl {
@@ -88,6 +89,7 @@ func NewRepoManagerImpl(db *gorm.DB, cfg *config.Config) *RepoManagerImpl {
TransactionRepo: NewTransactionRepository(db),
MemberRepository: NewMemberRepository(db),
InProgressOrderRepo: NewInProgressOrderRepository(db),
PartnerSetting: NewPartnerSettingsRepository(db),
}
}