mirror of
https://gitlab.com/mbugroup/lti-api.git
synced 2026-05-20 13:31:56 +00:00
giovanni
614 lines
18 KiB
Go
614 lines
18 KiB
Go
package controller
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"strconv"
|
|
"strings"
|
|
|
|
m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
|
|
"gitlab.com/mbugroup/lti-api.git/internal/modules/repports/dto"
|
|
service "gitlab.com/mbugroup/lti-api.git/internal/modules/repports/services"
|
|
validation "gitlab.com/mbugroup/lti-api.git/internal/modules/repports/validations"
|
|
"gitlab.com/mbugroup/lti-api.git/internal/response"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
)
|
|
|
|
// === Marketing Report Response ===
|
|
|
|
type MarketingReportResponse struct {
|
|
Code int `json:"code"`
|
|
Status string `json:"status"`
|
|
Message string `json:"message"`
|
|
Meta response.Meta `json:"meta"`
|
|
Data []dto.RepportMarketingItemDTO `json:"data"`
|
|
Total *dto.Summary `json:"total,omitempty"`
|
|
}
|
|
|
|
type RepportController struct {
|
|
RepportService service.RepportService
|
|
}
|
|
|
|
const expenseReportExcelExportFetchLimit = 100
|
|
|
|
func NewRepportController(repportService service.RepportService) *RepportController {
|
|
return &RepportController{
|
|
RepportService: repportService,
|
|
}
|
|
}
|
|
|
|
func (c *RepportController) GetExpense(ctx *fiber.Ctx) error {
|
|
query := &validation.ExpenseQuery{
|
|
Page: ctx.QueryInt("page", 1),
|
|
Limit: ctx.QueryInt("limit", 10),
|
|
Search: ctx.Query("search", ""),
|
|
Category: ctx.Query("category", ""),
|
|
SupplierId: int64(ctx.QueryInt("supplier_id", 0)),
|
|
KandangId: int64(ctx.QueryInt("kandang_id", 0)),
|
|
ProjectFlockKandangId: int64(ctx.QueryInt("project_flock_kandang_id", 0)),
|
|
NonstockId: int64(ctx.QueryInt("nonstock_id", 0)),
|
|
AreaId: int64(ctx.QueryInt("area_id", 0)),
|
|
LocationId: int64(ctx.QueryInt("location_id", 0)),
|
|
RealizationDate: ctx.Query("realization_date", ""),
|
|
SortBy: ctx.Query("sort_by", ""),
|
|
SortOrder: ctx.Query("sort_order", ""),
|
|
}
|
|
|
|
locationScope, err := m.ResolveLocationScope(ctx, c.RepportService.DB())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
areaScope, err := m.ResolveAreaScope(ctx, c.RepportService.DB())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if locationScope.Restrict {
|
|
query.AllowedLocationIDs = toInt64Slice(locationScope.IDs)
|
|
}
|
|
if areaScope.Restrict {
|
|
query.AllowedAreaIDs = toInt64Slice(areaScope.IDs)
|
|
}
|
|
|
|
if isAllExpenseExcelExportRequest(ctx) {
|
|
allResults, err := c.getAllExpenseRowsForExcel(ctx, query)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return exportExpenseReportListExcel(ctx, allResults)
|
|
}
|
|
|
|
if query.Page < 1 || query.Limit < 1 {
|
|
return fiber.NewError(fiber.StatusBadRequest, "page and limit must be greater than 0")
|
|
}
|
|
|
|
result, totalResults, err := c.RepportService.GetExpense(ctx, query)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return ctx.Status(fiber.StatusOK).
|
|
JSON(response.SuccessWithPaginate[dto.RepportExpenseListDTO]{
|
|
Code: fiber.StatusOK,
|
|
Status: "success",
|
|
Message: "Get expense report successfully",
|
|
Meta: response.Meta{
|
|
Page: query.Page,
|
|
Limit: query.Limit,
|
|
TotalPages: int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
|
|
TotalResults: totalResults,
|
|
},
|
|
Data: result,
|
|
})
|
|
}
|
|
|
|
func (c *RepportController) getAllExpenseRowsForExcel(ctx *fiber.Ctx, baseQuery *validation.ExpenseQuery) ([]dto.RepportExpenseListDTO, error) {
|
|
query := *baseQuery
|
|
query.Page = 1
|
|
query.Limit = expenseReportExcelExportFetchLimit
|
|
|
|
results := make([]dto.RepportExpenseListDTO, 0)
|
|
for {
|
|
pageResults, total, err := c.RepportService.GetExpense(ctx, &query)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if len(pageResults) == 0 || total == 0 {
|
|
break
|
|
}
|
|
|
|
results = append(results, pageResults...)
|
|
if int64(len(results)) >= total {
|
|
break
|
|
}
|
|
|
|
query.Page++
|
|
}
|
|
|
|
return results, nil
|
|
}
|
|
|
|
func (c *RepportController) GetExpenseDepreciation(ctx *fiber.Ctx) error {
|
|
rows, meta, err := c.RepportService.GetExpenseDepreciation(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
resp := struct {
|
|
Code int `json:"code"`
|
|
Status string `json:"status"`
|
|
Message string `json:"message"`
|
|
Meta dto.ExpenseDepreciationMetaDTO `json:"meta"`
|
|
Data []dto.ExpenseDepreciationRowDTO `json:"data"`
|
|
}{
|
|
Code: fiber.StatusOK,
|
|
Status: "success",
|
|
Message: "Get expense depreciation report successfully",
|
|
Meta: *meta,
|
|
Data: rows,
|
|
}
|
|
|
|
return ctx.Status(fiber.StatusOK).JSON(resp)
|
|
}
|
|
|
|
func (c *RepportController) GetExpenseDepreciationManualInputs(ctx *fiber.Ctx) error {
|
|
rows, meta, err := c.RepportService.GetExpenseDepreciationManualInputs(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
resp := struct {
|
|
Code int `json:"code"`
|
|
Status string `json:"status"`
|
|
Message string `json:"message"`
|
|
Meta dto.ExpenseDepreciationMetaDTO `json:"meta"`
|
|
Data []dto.ExpenseDepreciationManualInputRowDTO `json:"data"`
|
|
}{
|
|
Code: fiber.StatusOK,
|
|
Status: "success",
|
|
Message: "Get expense depreciation manual inputs successfully",
|
|
Meta: *meta,
|
|
Data: rows,
|
|
}
|
|
|
|
return ctx.Status(fiber.StatusOK).JSON(resp)
|
|
}
|
|
|
|
func (c *RepportController) UpsertExpenseDepreciationManualInput(ctx *fiber.Ctx) error {
|
|
req := new(validation.ExpenseDepreciationManualInputUpsert)
|
|
if err := ctx.BodyParser(req); err != nil {
|
|
return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
|
|
}
|
|
|
|
if err := m.EnsureProjectFlockAccess(ctx, c.RepportService.DB(), req.ProjectFlockID); err != nil {
|
|
return err
|
|
}
|
|
|
|
result, err := c.RepportService.UpsertExpenseDepreciationManualInput(ctx, req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return ctx.Status(fiber.StatusOK).JSON(response.Success{
|
|
Code: fiber.StatusOK,
|
|
Status: "success",
|
|
Message: "Upsert expense depreciation manual input successfully",
|
|
Data: result,
|
|
})
|
|
}
|
|
|
|
func (c *RepportController) GetMarketing(ctx *fiber.Ctx) error {
|
|
query := &validation.MarketingQuery{
|
|
Page: ctx.QueryInt("page", 1),
|
|
Limit: ctx.QueryInt("limit", 10),
|
|
Search: ctx.Query("search", ""),
|
|
CustomerId: int64(ctx.QueryInt("customer_id", 0)),
|
|
ProductId: int64(ctx.QueryInt("product_id", 0)),
|
|
WarehouseId: int64(ctx.QueryInt("warehouse_id", 0)),
|
|
SalesPersonId: int64(ctx.QueryInt("sales_person_id", 0)),
|
|
AreaId: int64(ctx.QueryInt("area_id", 0)),
|
|
LocationId: int64(ctx.QueryInt("location_id", 0)),
|
|
MarketingType: ctx.Query("marketing_type", ""),
|
|
FilterBy: ctx.Query("filter_by", ""),
|
|
StartDate: ctx.Query("start_date", ""),
|
|
EndDate: ctx.Query("end_date", ""),
|
|
SortBy: ctx.Query("sort_by", ""),
|
|
SortOrder: ctx.Query("sort_order", ""),
|
|
}
|
|
|
|
locationScope, err := m.ResolveLocationScope(ctx, c.RepportService.DB())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
areaScope, err := m.ResolveAreaScope(ctx, c.RepportService.DB())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if locationScope.Restrict {
|
|
allowed := toInt64Slice(locationScope.IDs)
|
|
if len(allowed) == 0 {
|
|
allowed = []int64{-1}
|
|
}
|
|
query.AllowedLocationIDs = allowed
|
|
}
|
|
if areaScope.Restrict {
|
|
allowed := toInt64Slice(areaScope.IDs)
|
|
if len(allowed) == 0 {
|
|
allowed = []int64{-1}
|
|
}
|
|
query.AllowedAreaIDs = allowed
|
|
}
|
|
|
|
if query.Page < 1 || query.Limit < 1 {
|
|
return fiber.NewError(fiber.StatusBadRequest, "page and limit must be greater than 0")
|
|
}
|
|
|
|
result, totalResults, err := c.RepportService.GetMarketing(ctx, query)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if isMarketingExcelExportRequest(ctx) {
|
|
return exportMarketingReportExcel(ctx, result)
|
|
}
|
|
|
|
if isMarketingPdfExportRequest(ctx) {
|
|
meta := buildMarketingPdfMeta(query.StartDate, query.EndDate)
|
|
return exportMarketingReportPdf(ctx, result, meta)
|
|
}
|
|
|
|
total := dto.ToSummaryFromDTOItems(result)
|
|
|
|
return ctx.Status(fiber.StatusOK).
|
|
JSON(MarketingReportResponse{
|
|
Code: fiber.StatusOK,
|
|
Status: "success",
|
|
Message: "Get marketing report successfully",
|
|
Meta: response.Meta{
|
|
Page: query.Page,
|
|
Limit: query.Limit,
|
|
TotalPages: int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
|
|
TotalResults: totalResults,
|
|
},
|
|
Data: result,
|
|
Total: total,
|
|
})
|
|
}
|
|
|
|
func (c *RepportController) GetPurchaseSupplier(ctx *fiber.Ctx) error {
|
|
areaIDs, err := parseCommaSeparatedInt64sWithField(ctx.Query("area_id", ""), "area_id")
|
|
if err != nil {
|
|
return fiber.NewError(fiber.StatusBadRequest, err.Error())
|
|
}
|
|
supplierIDs, err := parseCommaSeparatedInt64sWithField(ctx.Query("supplier_id", ""), "supplier_id")
|
|
if err != nil {
|
|
return fiber.NewError(fiber.StatusBadRequest, err.Error())
|
|
}
|
|
productIDs, err := parseCommaSeparatedInt64sWithField(ctx.Query("product_id", ""), "product_id")
|
|
if err != nil {
|
|
return fiber.NewError(fiber.StatusBadRequest, err.Error())
|
|
}
|
|
productCategoryIDs, err := parseCommaSeparatedInt64sWithField(ctx.Query("product_category_id", ""), "product_category_id")
|
|
if err != nil {
|
|
return fiber.NewError(fiber.StatusBadRequest, err.Error())
|
|
}
|
|
|
|
query := &validation.PurchaseSupplierQuery{
|
|
Page: ctx.QueryInt("page", 1),
|
|
Limit: ctx.QueryInt("limit", 10),
|
|
AreaIDs: areaIDs,
|
|
SupplierIDs: supplierIDs,
|
|
ProductIDs: productIDs,
|
|
ProductCategoryIDs: productCategoryIDs,
|
|
StartDate: ctx.Query("start_date", ""),
|
|
EndDate: ctx.Query("end_date", ""),
|
|
SortBy: ctx.Query("sort_by", ""),
|
|
FilterBy: ctx.Query("filter_by", ""),
|
|
}
|
|
|
|
areaScope, err := m.ResolveAreaScope(ctx, c.RepportService.DB())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if areaScope.Restrict {
|
|
query.AllowedAreaIDs = toInt64Slice(areaScope.IDs)
|
|
}
|
|
|
|
if query.Page < 1 || query.Limit < 1 {
|
|
return fiber.NewError(fiber.StatusBadRequest, "page and limit must be greater than 0")
|
|
}
|
|
|
|
result, totalResults, err := c.RepportService.GetPurchaseSupplier(ctx, query)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
filters := map[string]interface{}{
|
|
"area_id": query.AreaIDs,
|
|
"supplier_id": query.SupplierIDs,
|
|
"product_id": query.ProductIDs,
|
|
"product_category_id": query.ProductCategoryIDs,
|
|
"start_date": query.StartDate,
|
|
"end_date": query.EndDate,
|
|
"sort_by": query.SortBy,
|
|
"filter_by": query.FilterBy,
|
|
}
|
|
|
|
return ctx.Status(fiber.StatusOK).
|
|
JSON(response.SuccessWithPaginate[dto.PurchaseSupplierDTO]{
|
|
Code: fiber.StatusOK,
|
|
Status: "success",
|
|
Message: "Get supplier purchase recap successfully",
|
|
Meta: response.Meta{
|
|
Page: query.Page,
|
|
Limit: query.Limit,
|
|
TotalPages: int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
|
|
TotalResults: totalResults,
|
|
Filters: filters,
|
|
},
|
|
Data: result,
|
|
})
|
|
}
|
|
|
|
func (c *RepportController) GetDebtSupplier(ctx *fiber.Ctx) error {
|
|
supplierIDs, err := parseCommaSeparatedInt64s(ctx.Query("supplier_ids", ""))
|
|
if err != nil {
|
|
return fiber.NewError(fiber.StatusBadRequest, err.Error())
|
|
}
|
|
|
|
query := &validation.DebtSupplierQuery{
|
|
Page: ctx.QueryInt("page", 1),
|
|
Limit: ctx.QueryInt("limit", 10),
|
|
SupplierIDs: supplierIDs,
|
|
StartDate: ctx.Query("start_date", ""),
|
|
EndDate: ctx.Query("end_date", ""),
|
|
FilterBy: ctx.Query("filter_by", ""),
|
|
SortBy: ctx.Query("sort_by", ""),
|
|
SortOrder: ctx.Query("sort_order", ""),
|
|
}
|
|
|
|
locationScope, err := m.ResolveLocationScope(ctx, c.RepportService.DB())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
areaScope, err := m.ResolveAreaScope(ctx, c.RepportService.DB())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if locationScope.Restrict {
|
|
query.AllowedLocationIDs = toInt64Slice(locationScope.IDs)
|
|
}
|
|
if areaScope.Restrict {
|
|
query.AllowedAreaIDs = toInt64Slice(areaScope.IDs)
|
|
}
|
|
|
|
if query.Page < 1 || query.Limit < 1 {
|
|
return fiber.NewError(fiber.StatusBadRequest, "page and limit must be greater than 0")
|
|
}
|
|
|
|
result, totalResults, err := c.RepportService.GetDebtSupplier(ctx, query)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
supplierIDs = query.SupplierIDs
|
|
if supplierIDs == nil {
|
|
supplierIDs = []int64{}
|
|
}
|
|
|
|
filters := map[string]interface{}{
|
|
"start_date": query.StartDate,
|
|
"end_date": query.EndDate,
|
|
"supplier_ids": supplierIDs,
|
|
"filter_by": query.FilterBy,
|
|
}
|
|
|
|
return ctx.Status(fiber.StatusOK).
|
|
JSON(response.SuccessWithPaginate[dto.DebtSupplierDTO]{
|
|
Code: fiber.StatusOK,
|
|
Status: "success",
|
|
Message: "Get supplier debt recap successfully",
|
|
Meta: response.Meta{
|
|
Page: query.Page,
|
|
Limit: query.Limit,
|
|
TotalPages: int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
|
|
TotalResults: totalResults,
|
|
Filters: filters,
|
|
},
|
|
Data: result,
|
|
})
|
|
}
|
|
|
|
func (c *RepportController) GetHppPerKandang(ctx *fiber.Ctx) error {
|
|
data, meta, err := c.RepportService.GetHppPerKandang(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
resp := struct {
|
|
Code int `json:"code"`
|
|
Status string `json:"status"`
|
|
Message string `json:"message"`
|
|
Meta dto.HppPerKandangMetaDTO `json:"meta"`
|
|
Data dto.HppPerKandangResponseData `json:"data"`
|
|
}{
|
|
Code: fiber.StatusOK,
|
|
Status: "success",
|
|
Message: "Get HPP harian kandang layer successfully",
|
|
Meta: *meta,
|
|
Data: *data,
|
|
}
|
|
|
|
return ctx.Status(fiber.StatusOK).JSON(resp)
|
|
}
|
|
|
|
func (c *RepportController) GetCustomerPayment(ctx *fiber.Ctx) error {
|
|
var customerIDs []uint
|
|
if customerIDsStr := ctx.Query("customer_ids"); customerIDsStr != "" {
|
|
ids := strings.Split(customerIDsStr, ",")
|
|
for _, idStr := range ids {
|
|
idStr = strings.TrimSpace(idStr)
|
|
if idStr != "" {
|
|
if id, err := strconv.ParseUint(idStr, 10, 32); err == nil {
|
|
customerIDs = append(customerIDs, uint(id))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
query := &validation.CustomerPaymentQuery{
|
|
Page: ctx.QueryInt("page", 1),
|
|
Limit: ctx.QueryInt("limit", 10),
|
|
CustomerIDs: customerIDs,
|
|
FilterBy: strings.ToUpper(ctx.Query("filter_by", "")),
|
|
SortBy: ctx.Query("sort_by", ""),
|
|
SortOrder: ctx.Query("sort_order", ""),
|
|
StartDate: ctx.Query("start_date", ""),
|
|
EndDate: ctx.Query("end_date", ""),
|
|
}
|
|
|
|
// Validate pagination
|
|
if len(customerIDs) == 0 && (query.Page < 1 || query.Limit < 1) {
|
|
return fiber.NewError(fiber.StatusBadRequest, "page and limit must be greater than 0 when customer_ids is not provided")
|
|
}
|
|
|
|
result, totalResults, err := c.RepportService.GetCustomerPayment(ctx, query)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// If single customer mode (only 1 customer ID), return without pagination
|
|
if len(customerIDs) == 1 {
|
|
return ctx.Status(fiber.StatusOK).
|
|
JSON(response.Success{
|
|
Code: fiber.StatusOK,
|
|
Status: "success",
|
|
Message: "Get customer payment report successfully",
|
|
Data: result,
|
|
})
|
|
}
|
|
|
|
// Multiple customers mode with pagination
|
|
return ctx.Status(fiber.StatusOK).
|
|
JSON(response.SuccessWithPaginate[dto.CustomerPaymentReportItem]{
|
|
Code: fiber.StatusOK,
|
|
Status: "success",
|
|
Message: "Get customer payment report successfully",
|
|
Meta: response.Meta{
|
|
Page: query.Page,
|
|
Limit: query.Limit,
|
|
TotalPages: int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
|
|
TotalResults: totalResults,
|
|
},
|
|
Data: result,
|
|
})
|
|
}
|
|
|
|
func (c *RepportController) GetProductionResult(ctx *fiber.Ctx) error {
|
|
idParam := ctx.Params("idProjectFlockKandang")
|
|
if idParam == "" {
|
|
return fiber.NewError(fiber.StatusBadRequest, "idProjectFlockKandang is required")
|
|
}
|
|
|
|
projectFlockKandangID, err := strconv.ParseUint(idParam, 10, 64)
|
|
if err != nil {
|
|
return fiber.NewError(fiber.StatusBadRequest, "invalid idProjectFlockKandang")
|
|
}
|
|
|
|
query := &validation.ProductionResultQuery{
|
|
Page: ctx.QueryInt("page", 1),
|
|
Limit: ctx.QueryInt("limit", 10),
|
|
ProjectFlockKandangID: uint(projectFlockKandangID),
|
|
}
|
|
|
|
if err := m.EnsureProjectFlockKandangAccess(ctx, c.RepportService.DB(), 0, query.ProjectFlockKandangID); err != nil {
|
|
return err
|
|
}
|
|
|
|
if query.Page < 1 || query.Limit < 1 {
|
|
return fiber.NewError(fiber.StatusBadRequest, "page and limit must be greater than 0")
|
|
}
|
|
|
|
data, totalResults, err := c.RepportService.GetProductionResult(ctx, query)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return ctx.Status(fiber.StatusOK).
|
|
JSON(response.SuccessWithPaginate[dto.ProductionResultDTO]{
|
|
Code: fiber.StatusOK,
|
|
Status: "success",
|
|
Message: "Get Laporan Hasil Produksi successfully",
|
|
Meta: response.Meta{
|
|
Page: query.Page,
|
|
Limit: query.Limit,
|
|
TotalPages: int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
|
|
TotalResults: totalResults,
|
|
},
|
|
Data: data,
|
|
})
|
|
}
|
|
|
|
func (c *RepportController) GetHppV2Breakdown(ctx *fiber.Ctx) error {
|
|
query := &validation.HppV2BreakdownQuery{
|
|
ProjectFlockKandangID: uint(ctx.QueryInt("project_flock_kandang_id", 0)),
|
|
Period: ctx.Query("period", ""),
|
|
}
|
|
|
|
if err := m.EnsureProjectFlockKandangAccess(ctx, c.RepportService.DB(), 0, query.ProjectFlockKandangID); err != nil {
|
|
return err
|
|
}
|
|
|
|
data, err := c.RepportService.GetHppV2Breakdown(ctx, query)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return ctx.Status(fiber.StatusOK).JSON(response.Success{
|
|
Code: fiber.StatusOK,
|
|
Status: "success",
|
|
Message: "Get HPP v2 breakdown successfully",
|
|
Data: data,
|
|
})
|
|
}
|
|
|
|
func parseCommaSeparatedInt64s(raw string) ([]int64, error) {
|
|
return parseCommaSeparatedInt64sWithField(raw, "supplier_ids")
|
|
}
|
|
|
|
func parseCommaSeparatedInt64sWithField(raw, field string) ([]int64, error) {
|
|
raw = strings.TrimSpace(raw)
|
|
if raw == "" {
|
|
return []int64{}, nil
|
|
}
|
|
|
|
parts := strings.Split(raw, ",")
|
|
result := make([]int64, 0, len(parts))
|
|
for _, part := range parts {
|
|
part = strings.TrimSpace(part)
|
|
if part == "" {
|
|
continue
|
|
}
|
|
|
|
id, err := strconv.ParseInt(part, 10, 64)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%s must be comma separated integers", field)
|
|
}
|
|
result = append(result, id)
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func toInt64Slice(ids []uint) []int64 {
|
|
if len(ids) == 0 {
|
|
return nil
|
|
}
|
|
out := make([]int64, 0, len(ids))
|
|
for _, id := range ids {
|
|
out = append(out, int64(id))
|
|
}
|
|
return out
|
|
}
|