apskel-pos-backend/internal/transformer/expense_transformer.go

package transformer

import (
	"apskel-pos-be/internal/contract"
	"apskel-pos-be/internal/models"
	"apskel-pos-be/internal/util"
)

func CreateExpenseRequestToModel(req *contract.CreateExpenseRequest) *models.CreateExpenseRequest {
	items := make([]models.CreateExpenseItemRequest, len(req.Items))
	for i, item := range req.Items {
		items[i] = CreateExpenseItemRequestToModel(&item)
	}

	return &models.CreateExpenseRequest{
		Receiver:        req.Receiver,
		TransactionDate: req.TransactionDate,
		CodeNumber:      req.CodeNumber,
		OutletID:        req.OutletID,
		Status:          req.Status,
		Description:     req.Description,
		Tax:             req.Tax,
		Total:           req.Total,
		Items:           items,
	}
}

func CreateExpenseItemRequestToModel(req *contract.CreateExpenseItemRequest) models.CreateExpenseItemRequest {
	return models.CreateExpenseItemRequest{
		ChartOfAccountID:   req.ChartOfAccountID,
		PurchaseCategoryID: req.PurchaseCategoryID,
		Item:               req.Item,
		Description:        req.Description,
		Amount:             req.Amount,
	}
}

func UpdateExpenseRequestToModel(req *contract.UpdateExpenseRequest) *models.UpdateExpenseRequest {
	modelReq := &models.UpdateExpenseRequest{
		Receiver:        req.Receiver,
		TransactionDate: req.TransactionDate,
		CodeNumber:      req.CodeNumber,
		OutletID:        req.OutletID,
		Status:          req.Status,
		Description:     req.Description,
		Tax:             req.Tax,
		Total:           req.Total,
		Reserved1:       req.Reserved1,
	}

	if req.Items != nil {
		items := make([]models.UpdateExpenseItemRequest, len(req.Items))
		for i, item := range req.Items {
			items[i] = UpdateExpenseItemRequestToModel(&item)
		}
		modelReq.Items = items
	}

	return modelReq
}

func UpdateExpenseItemRequestToModel(req *contract.UpdateExpenseItemRequest) models.UpdateExpenseItemRequest {
	return models.UpdateExpenseItemRequest{
		ChartOfAccountID:   req.ChartOfAccountID,
		PurchaseCategoryID: req.PurchaseCategoryID,
		Item:               req.Item,
		Description:        req.Description,
		Amount:             req.Amount,
	}
}

func ListExpenseRequestToModel(req *contract.ListExpenseRequest) *models.ListExpenseRequest {
	return &models.ListExpenseRequest{
		Page:      req.Page,
		Limit:     req.Limit,
		Search:    req.Search,
		OutletID:  req.OutletID,
		Status:    req.Status,
		StartDate: req.StartDate,
		EndDate:   req.EndDate,
	}
}

func ExpenseModelResponseToResponse(expense *models.ExpenseResponse) *contract.ExpenseResponse {
	if expense == nil {
		return nil
	}

	items := make([]contract.ExpenseItemResponse, len(expense.Items))
	for i, item := range expense.Items {
		items[i] = ExpenseItemModelResponseToResponse(&item)
	}

	return &contract.ExpenseResponse{
		ID:              expense.ID,
		OrganizationID:  expense.OrganizationID,
		OutletID:        expense.OutletID,
		Receiver:        expense.Receiver,
		TransactionDate: expense.TransactionDate,
		CodeNumber:      expense.CodeNumber,
		Status:          expense.Status,
		Description:     expense.Description,
		Tax:             expense.Tax,
		Total:           expense.Total,
		Reserved1:       expense.Reserved1,
		CreatedAt:       expense.CreatedAt,
		UpdatedAt:       expense.UpdatedAt,
		Items:           items,
	}
}

func ExpenseItemModelResponseToResponse(item *models.ExpenseItemResponse) contract.ExpenseItemResponse {
	return contract.ExpenseItemResponse{
		ID:                   item.ID,
		ExpenseID:            item.ExpenseID,
		ChartOfAccountID:     item.ChartOfAccountID,
		ChartOfAccountName:   item.ChartOfAccountName,
		PurchaseCategoryID:   item.PurchaseCategoryID,
		PurchaseCategoryName: item.PurchaseCategoryName,
		PurchaseCategoryType: item.PurchaseCategoryType,
		PurchaseCategory:     PurchaseCategoryModelResponseToResponse(item.PurchaseCategory),
		Item:                 item.Item,
		Description:          item.Description,
		Amount:               item.Amount,
		CreatedAt:            item.CreatedAt,
		UpdatedAt:            item.UpdatedAt,
	}
}

func ExpenseModelResponsesToResponses(expenses []*models.ExpenseResponse) []contract.ExpenseResponse {
	if expenses == nil {
		return nil
	}

	responses := make([]contract.ExpenseResponse, len(expenses))
	for i, expense := range expenses {
		response := ExpenseModelResponseToResponse(expense)
		if response != nil {
			responses[i] = *response
		}
	}
	return responses
}

func ExpenseAnalyticsRequestToModel(req *contract.ExpenseAnalyticsRequest) (*models.ExpenseAnalyticsRequest, error) {
	dateFrom, dateTo, err := util.ParseDateRangeToJakartaTime(req.DateFrom, req.DateTo)
	if err != nil {
		return nil, err
	}

	modelReq := &models.ExpenseAnalyticsRequest{
		OutletID: parseOutletID(req.OutletID),
		GroupBy:  req.GroupBy,
	}
	if dateFrom != nil {
		modelReq.DateFrom = *dateFrom
	}
	if dateTo != nil {
		modelReq.DateTo = *dateTo
	}

	return modelReq, nil
}

func ExpenseAnalyticsModelToContract(resp *models.ExpenseAnalyticsResponse) *contract.ExpenseAnalyticsResponse {
	if resp == nil {
		return nil
	}

	data := make([]contract.ExpenseAnalyticsData, len(resp.Data))
	for i, item := range resp.Data {
		data[i] = contract.ExpenseAnalyticsData{
			Date:         item.Date,
			Expenses:     item.Expenses,
			ExpenseCount: item.ExpenseCount,
			Tax:          item.Tax,
			Items:        item.Items,
			Categories:   item.Categories,
		}
	}

	categoryData := make([]contract.ExpenseAnalyticsCategoryData, len(resp.CategoryData))
	for i, item := range resp.CategoryData {
		categoryData[i] = contract.ExpenseAnalyticsCategoryData{
			PurchaseCategoryID:   item.PurchaseCategoryID,
			PurchaseCategoryName: item.PurchaseCategoryName,
			PurchaseCategoryType: item.PurchaseCategoryType,
			TotalAmount:          item.TotalAmount,
			ExpenseCount:         item.ExpenseCount,
			ItemCount:            item.ItemCount,
		}
	}

	chartOfAccountData := make([]contract.ExpenseAnalyticsChartOfAccountData, len(resp.ChartOfAccountData))
	for i, item := range resp.ChartOfAccountData {
		chartOfAccountData[i] = contract.ExpenseAnalyticsChartOfAccountData{
			ChartOfAccountID:   item.ChartOfAccountID,
			ChartOfAccountName: item.ChartOfAccountName,
			TotalAmount:        item.TotalAmount,
			ExpenseCount:       item.ExpenseCount,
			ItemCount:          item.ItemCount,
		}
	}

	itemData := make([]contract.ExpenseAnalyticsItemData, len(resp.ItemData))
	for i, item := range resp.ItemData {
		itemData[i] = contract.ExpenseAnalyticsItemData{
			Item:         item.Item,
			TotalAmount:  item.TotalAmount,
			ExpenseCount: item.ExpenseCount,
			ItemCount:    item.ItemCount,
		}
	}

	return &contract.ExpenseAnalyticsResponse{
		OrganizationID: resp.OrganizationID,
		OutletID:       resp.OutletID,
		DateFrom:       resp.DateFrom,
		DateTo:         resp.DateTo,
		GroupBy:        resp.GroupBy,
		Summary: contract.ExpenseAnalyticsSummary{
			TotalExpenses:       resp.Summary.TotalExpenses,
			TotalExpenseCount:   resp.Summary.TotalExpenseCount,
			TotalTax:            resp.Summary.TotalTax,
			AverageExpenseValue: resp.Summary.AverageExpenseValue,
			TotalCategories:     resp.Summary.TotalCategories,
			TotalItems:          resp.Summary.TotalItems,
		},
		Data:               data,
		CategoryData:       categoryData,
		ChartOfAccountData: chartOfAccountData,
		ItemData:           itemData,
	}
}