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

Add coa purchase and vendors

Browse Source
This commit is contained in:
Aditya Siregar
2025-09-12 01:12:11 +07:00
parent c107733add
commit efe09c21e4
86 changed files with 8517 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/mappers/account_mapper.go
+73
View File
@@ -0,0 +1,73 @@
package mappers
import (
"apskel-pos-be/internal/entities"
"apskel-pos-be/internal/models"
"github.com/google/uuid"
)
func AccountEntityToResponse(entity *entities.Account) *models.AccountResponse {
response := &models.AccountResponse{
ID: entity.ID,
OrganizationID: entity.OrganizationID,
OutletID: entity.OutletID,
ChartOfAccountID: entity.ChartOfAccountID,
Name: entity.Name,
Number: entity.Number,
AccountType: string(entity.AccountType),
OpeningBalance: entity.OpeningBalance,
CurrentBalance: entity.CurrentBalance,
Description: entity.Description,
IsActive: entity.IsActive,
IsSystem: entity.IsSystem,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
}
if entity.ChartOfAccount.ID != uuid.Nil {
response.ChartOfAccount = ChartOfAccountEntityToResponse(&entity.ChartOfAccount)
}
return response
}
func AccountCreateRequestToEntity(req *models.CreateAccountRequest, organizationID uuid.UUID, outletID *uuid.UUID) *entities.Account {
return &entities.Account{
OrganizationID: organizationID,
OutletID: outletID,
ChartOfAccountID: req.ChartOfAccountID,
Name: req.Name,
Number: req.Number,
AccountType: entities.AccountType(req.AccountType),
OpeningBalance: req.OpeningBalance,
CurrentBalance: req.OpeningBalance, // Initialize current balance with opening balance
Description: req.Description,
IsActive: true,
IsSystem: false,
}
}
func AccountUpdateRequestToEntity(entity *entities.Account, req *models.UpdateAccountRequest) {
if req.ChartOfAccountID != nil {
entity.ChartOfAccountID = *req.ChartOfAccountID
}
if req.Name != nil {
entity.Name = *req.Name
}
if req.Number != nil {
entity.Number = *req.Number
}
if req.AccountType != nil {
entity.AccountType = entities.AccountType(*req.AccountType)
}
if req.OpeningBalance != nil {
entity.OpeningBalance = *req.OpeningBalance
}
if req.Description != nil {
entity.Description = req.Description
}
if req.IsActive != nil {
entity.IsActive = *req.IsActive
}
}
internal/mappers/chart_of_account_mapper.go
+77
View File
@@ -0,0 +1,77 @@
package mappers
import (
"apskel-pos-be/internal/entities"
"apskel-pos-be/internal/models"
"github.com/google/uuid"
)
func ChartOfAccountEntityToResponse(entity *entities.ChartOfAccount) *models.ChartOfAccountResponse {
response := &models.ChartOfAccountResponse{
ID: entity.ID,
OrganizationID: entity.OrganizationID,
OutletID: entity.OutletID,
ChartOfAccountTypeID: entity.ChartOfAccountTypeID,
ParentID: entity.ParentID,
Name: entity.Name,
Code: entity.Code,
Description: entity.Description,
IsActive: entity.IsActive,
IsSystem: entity.IsSystem,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
}
if entity.ChartOfAccountType.ID != uuid.Nil {
response.ChartOfAccountType = ChartOfAccountTypeEntityToResponse(&entity.ChartOfAccountType)
}
if entity.Parent != nil {
response.Parent = ChartOfAccountEntityToResponse(entity.Parent)
}
if len(entity.Children) > 0 {
response.Children = make([]models.ChartOfAccountResponse, len(entity.Children))
for i, child := range entity.Children {
response.Children[i] = *ChartOfAccountEntityToResponse(&child)
}
}
return response
}
func ChartOfAccountCreateRequestToEntity(req *models.CreateChartOfAccountRequest, organizationID uuid.UUID, outletID *uuid.UUID) *entities.ChartOfAccount {
return &entities.ChartOfAccount{
OrganizationID: organizationID,
OutletID: outletID,
ChartOfAccountTypeID: req.ChartOfAccountTypeID,
ParentID: req.ParentID,
Name: req.Name,
Code: req.Code,
Description: req.Description,
IsActive: true,
IsSystem: false,
}
}
func ChartOfAccountUpdateRequestToEntity(entity *entities.ChartOfAccount, req *models.UpdateChartOfAccountRequest) {
if req.ChartOfAccountTypeID != nil {
entity.ChartOfAccountTypeID = *req.ChartOfAccountTypeID
}
if req.ParentID != nil {
entity.ParentID = req.ParentID
}
if req.Name != nil {
entity.Name = *req.Name
}
if req.Code != nil {
entity.Code = *req.Code
}
if req.Description != nil {
entity.Description = req.Description
}
if req.IsActive != nil {
entity.IsActive = *req.IsActive
}
}
internal/mappers/chart_of_account_type_mapper.go
+42
View File
@@ -0,0 +1,42 @@
package mappers
import (
"apskel-pos-be/internal/entities"
"apskel-pos-be/internal/models"
)
func ChartOfAccountTypeEntityToResponse(entity *entities.ChartOfAccountType) *models.ChartOfAccountTypeResponse {
return &models.ChartOfAccountTypeResponse{
ID: entity.ID,
Name: entity.Name,
Code: entity.Code,
Description: entity.Description,
IsActive: entity.IsActive,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
}
}
func ChartOfAccountTypeCreateRequestToEntity(req *models.CreateChartOfAccountTypeRequest) *entities.ChartOfAccountType {
return &entities.ChartOfAccountType{
Name: req.Name,
Code: req.Code,
Description: req.Description,
IsActive: true,
}
}
func ChartOfAccountTypeUpdateRequestToEntity(entity *entities.ChartOfAccountType, req *models.UpdateChartOfAccountTypeRequest) {
if req.Name != nil {
entity.Name = *req.Name
}
if req.Code != nil {
entity.Code = *req.Code
}
if req.Description != nil {
entity.Description = req.Description
}
if req.IsActive != nil {
entity.IsActive = *req.IsActive
}
}
internal/mappers/contract_mapper.go
+168
View File
@@ -0,0 +1,168 @@
package mappers
import (
"apskel-pos-be/internal/contract"
"apskel-pos-be/internal/models"
"time"
)
// Chart of Account Type Mappers
func ContractToModelCreateChartOfAccountTypeRequest(req *contract.CreateChartOfAccountTypeRequest) *models.CreateChartOfAccountTypeRequest {
return &models.CreateChartOfAccountTypeRequest{
Name: req.Name,
Code: req.Code,
Description: req.Description,
}
}
func ContractToModelUpdateChartOfAccountTypeRequest(req *contract.UpdateChartOfAccountTypeRequest) *models.UpdateChartOfAccountTypeRequest {
return &models.UpdateChartOfAccountTypeRequest{
Name: req.Name,
Code: req.Code,
Description: req.Description,
IsActive: req.IsActive,
}
}
func ModelToContractChartOfAccountTypeResponse(resp *models.ChartOfAccountTypeResponse) *contract.ChartOfAccountTypeResponse {
return &contract.ChartOfAccountTypeResponse{
ID: resp.ID,
Name: resp.Name,
Code: resp.Code,
Description: resp.Description,
IsActive: resp.IsActive,
CreatedAt: resp.CreatedAt.Format(time.RFC3339),
UpdatedAt: resp.UpdatedAt.Format(time.RFC3339),
}
}
// Chart of Account Mappers
func ContractToModelCreateChartOfAccountRequest(req *contract.CreateChartOfAccountRequest) *models.CreateChartOfAccountRequest {
return &models.CreateChartOfAccountRequest{
ChartOfAccountTypeID: req.ChartOfAccountTypeID,
ParentID: req.ParentID,
Name: req.Name,
Code: req.Code,
Description: req.Description,
}
}
func ContractToModelUpdateChartOfAccountRequest(req *contract.UpdateChartOfAccountRequest) *models.UpdateChartOfAccountRequest {
return &models.UpdateChartOfAccountRequest{
ChartOfAccountTypeID: req.ChartOfAccountTypeID,
ParentID: req.ParentID,
Name: req.Name,
Code: req.Code,
Description: req.Description,
IsActive: req.IsActive,
}
}
func ContractToModelListChartOfAccountsRequest(req *contract.ListChartOfAccountsRequest) *models.ListChartOfAccountsRequest {
return &models.ListChartOfAccountsRequest{
OrganizationID: req.OrganizationID,
OutletID: req.OutletID,
ChartOfAccountTypeID: req.ChartOfAccountTypeID,
ParentID: req.ParentID,
IsActive: req.IsActive,
IsSystem: req.IsSystem,
Page: req.Page,
Limit: req.Limit,
}
}
func ModelToContractChartOfAccountResponse(resp *models.ChartOfAccountResponse) *contract.ChartOfAccountResponse {
contractResp := &contract.ChartOfAccountResponse{
ID: resp.ID,
OrganizationID: resp.OrganizationID,
OutletID: resp.OutletID,
ChartOfAccountTypeID: resp.ChartOfAccountTypeID,
ParentID: resp.ParentID,
Name: resp.Name,
Code: resp.Code,
Description: resp.Description,
IsActive: resp.IsActive,
IsSystem: resp.IsSystem,
CreatedAt: resp.CreatedAt.Format(time.RFC3339),
UpdatedAt: resp.UpdatedAt.Format(time.RFC3339),
}
if resp.ChartOfAccountType != nil {
contractResp.ChartOfAccountType = ModelToContractChartOfAccountTypeResponse(resp.ChartOfAccountType)
}
if resp.Parent != nil {
contractResp.Parent = ModelToContractChartOfAccountResponse(resp.Parent)
}
if len(resp.Children) > 0 {
contractResp.Children = make([]contract.ChartOfAccountResponse, len(resp.Children))
for i, child := range resp.Children {
contractResp.Children[i] = *ModelToContractChartOfAccountResponse(&child)
}
}
return contractResp
}
// Account Mappers
func ContractToModelCreateAccountRequest(req *contract.CreateAccountRequest) *models.CreateAccountRequest {
return &models.CreateAccountRequest{
ChartOfAccountID: req.ChartOfAccountID,
Name: req.Name,
Number: req.Number,
AccountType: req.AccountType,
OpeningBalance: req.OpeningBalance,
Description: req.Description,
}
}
func ContractToModelUpdateAccountRequest(req *contract.UpdateAccountRequest) *models.UpdateAccountRequest {
return &models.UpdateAccountRequest{
ChartOfAccountID: req.ChartOfAccountID,
Name: req.Name,
Number: req.Number,
AccountType: req.AccountType,
OpeningBalance: req.OpeningBalance,
Description: req.Description,
IsActive: req.IsActive,
}
}
func ContractToModelListAccountsRequest(req *contract.ListAccountsRequest) *models.ListAccountsRequest {
return &models.ListAccountsRequest{
OrganizationID: req.OrganizationID,
OutletID: req.OutletID,
ChartOfAccountID: req.ChartOfAccountID,
AccountType: req.AccountType,
IsActive: req.IsActive,
IsSystem: req.IsSystem,
Page: req.Page,
Limit: req.Limit,
}
}
func ModelToContractAccountResponse(resp *models.AccountResponse) *contract.AccountResponse {
contractResp := &contract.AccountResponse{
ID: resp.ID,
OrganizationID: resp.OrganizationID,
OutletID: resp.OutletID,
ChartOfAccountID: resp.ChartOfAccountID,
Name: resp.Name,
Number: resp.Number,
AccountType: resp.AccountType,
OpeningBalance: resp.OpeningBalance,
CurrentBalance: resp.CurrentBalance,
Description: resp.Description,
IsActive: resp.IsActive,
IsSystem: resp.IsSystem,
CreatedAt: resp.CreatedAt.Format(time.RFC3339),
UpdatedAt: resp.UpdatedAt.Format(time.RFC3339),
}
if resp.ChartOfAccount != nil {
contractResp.ChartOfAccount = ModelToContractChartOfAccountResponse(resp.ChartOfAccount)
}
return contractResp
}
internal/mappers/ingredient_mapper.go
+23
View File
@@ -74,3 +74,26 @@ func MapIngredientModelsToEntities(models []*models.Ingredient) []*entities.Ingr
return entities
}
// Entity to Response conversions
func MapIngredientEntityToResponse(entity *entities.Ingredient) *models.IngredientResponse {
if entity == nil {
return nil
}
return &models.IngredientResponse{
ID: entity.ID,
OrganizationID: entity.OrganizationID,
OutletID: entity.OutletID,
Name: entity.Name,
UnitID: entity.UnitID,
Cost: entity.Cost,
Stock: entity.Stock,
IsSemiFinished: entity.IsSemiFinished,
IsActive: entity.IsActive,
Metadata: entity.Metadata,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
Unit: MapUnitEntityToModel(entity.Unit),
}
}
internal/mappers/ingredient_unit_converter_mapper.go
+91
View File
@@ -0,0 +1,91 @@
package mappers
import (
"apskel-pos-be/internal/entities"
"apskel-pos-be/internal/models"
)
// Entity to Model conversions
func IngredientUnitConverterEntityToModel(entity *entities.IngredientUnitConverter) *models.IngredientUnitConverter {
if entity == nil {
return nil
}
model := &models.IngredientUnitConverter{
ID: entity.ID,
OrganizationID: entity.OrganizationID,
IngredientID: entity.IngredientID,
FromUnitID: entity.FromUnitID,
ToUnitID: entity.ToUnitID,
ConversionFactor: entity.ConversionFactor,
IsActive: entity.IsActive,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
CreatedBy: entity.CreatedBy,
UpdatedBy: entity.UpdatedBy,
}
// Map related entities
if entity.Ingredient != nil {
model.Ingredient = MapIngredientEntityToModel(entity.Ingredient)
}
if entity.FromUnit != nil {
model.FromUnit = MapUnitEntityToModel(entity.FromUnit)
}
if entity.ToUnit != nil {
model.ToUnit = MapUnitEntityToModel(entity.ToUnit)
}
return model
}
// Entity to Response conversions
func IngredientUnitConverterEntityToResponse(entity *entities.IngredientUnitConverter) *models.IngredientUnitConverterResponse {
if entity == nil {
return nil
}
response := &models.IngredientUnitConverterResponse{
ID: entity.ID,
OrganizationID: entity.OrganizationID,
IngredientID: entity.IngredientID,
FromUnitID: entity.FromUnitID,
ToUnitID: entity.ToUnitID,
ConversionFactor: entity.ConversionFactor,
IsActive: entity.IsActive,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
CreatedBy: entity.CreatedBy,
UpdatedBy: entity.UpdatedBy,
}
// Map related entities
if entity.Ingredient != nil {
response.Ingredient = MapIngredientEntityToResponse(entity.Ingredient)
}
if entity.FromUnit != nil {
response.FromUnit = MapUnitEntityToResponse(entity.FromUnit)
}
if entity.ToUnit != nil {
response.ToUnit = MapUnitEntityToResponse(entity.ToUnit)
}
return response
}
// Batch conversion methods
func IngredientUnitConverterEntitiesToModels(entities []*entities.IngredientUnitConverter) []*models.IngredientUnitConverter {
models := make([]*models.IngredientUnitConverter, len(entities))
for i, entity := range entities {
models[i] = IngredientUnitConverterEntityToModel(entity)
}
return models
}
func IngredientUnitConverterEntitiesToResponses(entities []*entities.IngredientUnitConverter) []*models.IngredientUnitConverterResponse {
responses := make([]*models.IngredientUnitConverterResponse, len(entities))
for i, entity := range entities {
responses[i] = IngredientUnitConverterEntityToResponse(entity)
}
return responses
}
internal/mappers/purchase_order_mapper.go
+273
View File
@@ -0,0 +1,273 @@
package mappers
import (
"apskel-pos-be/internal/entities"
"apskel-pos-be/internal/models"
)
func PurchaseOrderEntityToModel(entity *entities.PurchaseOrder) *models.PurchaseOrder {
if entity == nil {
return nil
}
return &models.PurchaseOrder{
ID: entity.ID,
OrganizationID: entity.OrganizationID,
VendorID: entity.VendorID,
PONumber: entity.PONumber,
TransactionDate: entity.TransactionDate,
DueDate: entity.DueDate,
Reference: entity.Reference,
Status: entity.Status,
Message: entity.Message,
TotalAmount: entity.TotalAmount,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
}
}
func PurchaseOrderModelToEntity(model *models.PurchaseOrder) *entities.PurchaseOrder {
if model == nil {
return nil
}
return &entities.PurchaseOrder{
ID: model.ID,
OrganizationID: model.OrganizationID,
VendorID: model.VendorID,
PONumber: model.PONumber,
TransactionDate: model.TransactionDate,
DueDate: model.DueDate,
Reference: model.Reference,
Status: model.Status,
Message: model.Message,
TotalAmount: model.TotalAmount,
CreatedAt: model.CreatedAt,
UpdatedAt: model.UpdatedAt,
}
}
func PurchaseOrderEntityToResponse(entity *entities.PurchaseOrder) *models.PurchaseOrderResponse {
if entity == nil {
return nil
}
response := &models.PurchaseOrderResponse{
ID: entity.ID,
OrganizationID: entity.OrganizationID,
VendorID: entity.VendorID,
PONumber: entity.PONumber,
TransactionDate: entity.TransactionDate,
DueDate: entity.DueDate,
Reference: entity.Reference,
Status: entity.Status,
Message: entity.Message,
TotalAmount: entity.TotalAmount,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
}
// Map vendor if present
if entity.Vendor != nil {
response.Vendor = VendorEntityToResponse(entity.Vendor)
}
// Map items if present
if entity.Items != nil {
response.Items = PurchaseOrderItemEntitiesToResponses(entity.Items)
}
// Map attachments if present
if entity.Attachments != nil {
response.Attachments = PurchaseOrderAttachmentEntitiesToResponses(entity.Attachments)
}
return response
}
func PurchaseOrderItemEntityToModel(entity *entities.PurchaseOrderItem) *models.PurchaseOrderItem {
if entity == nil {
return nil
}
return &models.PurchaseOrderItem{
ID: entity.ID,
PurchaseOrderID: entity.PurchaseOrderID,
IngredientID: entity.IngredientID,
Description: entity.Description,
Quantity: entity.Quantity,
UnitID: entity.UnitID,
Amount: entity.Amount,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
}
}
func PurchaseOrderItemModelToEntity(model *models.PurchaseOrderItem) *entities.PurchaseOrderItem {
if model == nil {
return nil
}
return &entities.PurchaseOrderItem{
ID: model.ID,
PurchaseOrderID: model.PurchaseOrderID,
IngredientID: model.IngredientID,
Description: model.Description,
Quantity: model.Quantity,
UnitID: model.UnitID,
Amount: model.Amount,
CreatedAt: model.CreatedAt,
UpdatedAt: model.UpdatedAt,
}
}
func PurchaseOrderItemEntityToResponse(entity *entities.PurchaseOrderItem) *models.PurchaseOrderItemResponse {
if entity == nil {
return nil
}
response := &models.PurchaseOrderItemResponse{
ID: entity.ID,
PurchaseOrderID: entity.PurchaseOrderID,
IngredientID: entity.IngredientID,
Description: entity.Description,
Quantity: entity.Quantity,
UnitID: entity.UnitID,
Amount: entity.Amount,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
}
// Map ingredient if present
if entity.Ingredient != nil {
response.Ingredient = &models.IngredientResponse{
ID: entity.Ingredient.ID,
Name: entity.Ingredient.Name,
}
}
// Map unit if present
if entity.Unit != nil {
response.Unit = &models.UnitResponse{
ID: entity.Unit.ID,
Name: entity.Unit.Name,
}
}
return response
}
func PurchaseOrderAttachmentEntityToModel(entity *entities.PurchaseOrderAttachment) *models.PurchaseOrderAttachment {
if entity == nil {
return nil
}
return &models.PurchaseOrderAttachment{
ID: entity.ID,
PurchaseOrderID: entity.PurchaseOrderID,
FileID: entity.FileID,
CreatedAt: entity.CreatedAt,
}
}
func PurchaseOrderAttachmentModelToEntity(model *models.PurchaseOrderAttachment) *entities.PurchaseOrderAttachment {
if model == nil {
return nil
}
return &entities.PurchaseOrderAttachment{
ID: model.ID,
PurchaseOrderID: model.PurchaseOrderID,
FileID: model.FileID,
CreatedAt: model.CreatedAt,
}
}
func PurchaseOrderAttachmentEntityToResponse(entity *entities.PurchaseOrderAttachment) *models.PurchaseOrderAttachmentResponse {
if entity == nil {
return nil
}
response := &models.PurchaseOrderAttachmentResponse{
ID: entity.ID,
PurchaseOrderID: entity.PurchaseOrderID,
FileID: entity.FileID,
CreatedAt: entity.CreatedAt,
}
// Map file if present
if entity.File != nil {
response.File = &models.FileResponse{
ID: entity.File.ID,
FileName: entity.File.FileName,
OriginalName: entity.File.OriginalName,
FileURL: entity.File.FileURL,
FileSize: entity.File.FileSize,
MimeType: entity.File.MimeType,
FileType: entity.File.FileType,
IsPublic: entity.File.IsPublic,
CreatedAt: entity.File.CreatedAt,
UpdatedAt: entity.File.UpdatedAt,
}
}
return response
}
// Batch conversion methods
func PurchaseOrderEntitiesToModels(entities []*entities.PurchaseOrder) []*models.PurchaseOrder {
if entities == nil {
return nil
}
models := make([]*models.PurchaseOrder, len(entities))
for i, entity := range entities {
models[i] = PurchaseOrderEntityToModel(entity)
}
return models
}
func PurchaseOrderEntitiesToResponses(entities []*entities.PurchaseOrder) []models.PurchaseOrderResponse {
if entities == nil {
return nil
}
responses := make([]models.PurchaseOrderResponse, len(entities))
for i, entity := range entities {
response := PurchaseOrderEntityToResponse(entity)
if response != nil {
responses[i] = *response
}
}
return responses
}
func PurchaseOrderItemEntitiesToResponses(entities []entities.PurchaseOrderItem) []models.PurchaseOrderItemResponse {
if entities == nil {
return nil
}
responses := make([]models.PurchaseOrderItemResponse, len(entities))
for i, entity := range entities {
response := PurchaseOrderItemEntityToResponse(&entity)
if response != nil {
responses[i] = *response
}
}
return responses
}
func PurchaseOrderAttachmentEntitiesToResponses(entities []entities.PurchaseOrderAttachment) []models.PurchaseOrderAttachmentResponse {
if entities == nil {
return nil
}
responses := make([]models.PurchaseOrderAttachmentResponse, len(entities))
for i, entity := range entities {
response := PurchaseOrderAttachmentEntityToResponse(&entity)
if response != nil {
responses[i] = *response
}
}
return responses
}
internal/mappers/unit_mapper.go
+19
View File
@@ -66,3 +66,22 @@ func MapUnitModelsToEntities(models []*models.Unit) []*entities.Unit {
return entities
}
// Entity to Response conversions
func MapUnitEntityToResponse(entity *entities.Unit) *models.UnitResponse {
if entity == nil {
return nil
}
return &models.UnitResponse{
ID: entity.ID,
OrganizationID: entity.OrganizationID,
OutletID: entity.OutletID,
Name: entity.Name,
Abbreviation: entity.Abbreviation,
IsActive: entity.IsActive,
DeletedAt: entity.DeletedAt,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
}
}
internal/mappers/vendor_mapper.go
+96
View File
@@ -0,0 +1,96 @@
package mappers
import (
"apskel-pos-be/internal/entities"
"apskel-pos-be/internal/models"
)
func VendorEntityToModel(entity *entities.Vendor) *models.Vendor {
if entity == nil {
return nil
}
return &models.Vendor{
ID: entity.ID,
OrganizationID: entity.OrganizationID,
Name: entity.Name,
Email: entity.Email,
PhoneNumber: entity.PhoneNumber,
Address: entity.Address,
ContactPerson: entity.ContactPerson,
TaxNumber: entity.TaxNumber,
PaymentTerms: entity.PaymentTerms,
Notes: entity.Notes,
IsActive: entity.IsActive,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
}
}
func VendorModelToEntity(model *models.Vendor) *entities.Vendor {
if model == nil {
return nil
}
return &entities.Vendor{
ID: model.ID,
OrganizationID: model.OrganizationID,
Name: model.Name,
Email: model.Email,
PhoneNumber: model.PhoneNumber,
Address: model.Address,
ContactPerson: model.ContactPerson,
TaxNumber: model.TaxNumber,
PaymentTerms: model.PaymentTerms,
Notes: model.Notes,
IsActive: model.IsActive,
CreatedAt: model.CreatedAt,
UpdatedAt: model.UpdatedAt,
}
}
func VendorEntityToResponse(entity *entities.Vendor) *models.VendorResponse {
if entity == nil {
return nil
}
return &models.VendorResponse{
ID: entity.ID,
OrganizationID: entity.OrganizationID,
Name: entity.Name,
Email: entity.Email,
PhoneNumber: entity.PhoneNumber,
Address: entity.Address,
ContactPerson: entity.ContactPerson,
TaxNumber: entity.TaxNumber,
PaymentTerms: entity.PaymentTerms,
Notes: entity.Notes,
IsActive: entity.IsActive,
CreatedAt: entity.CreatedAt,
UpdatedAt: entity.UpdatedAt,
}
}
func VendorEntitiesToModels(entities []*entities.Vendor) []*models.Vendor {
if entities == nil {
return nil
}
models := make([]*models.Vendor, len(entities))
for i, entity := range entities {
models[i] = VendorEntityToModel(entity)
}
return models
}
func VendorEntitiesToResponses(entities []*entities.Vendor) []*models.VendorResponse {
if entities == nil {
return nil
}
responses := make([]*models.VendorResponse, len(entities))
for i, entity := range entities {
responses[i] = VendorEntityToResponse(entity)
}
return responses
}