daShangDao_psiServer/controllers/warehouse.go

package controllers

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/sirupsen/logrus"
	"net/http"
	"os"
	"psi/constant"
	"psi/database"
	systemReq "psi/models/request"
	systemRes "psi/models/response"
	"psi/service"
	"psi/utils"
	"strings"
	"time"
)

type WarehouseApi struct{}

var warehouseService = service.WarehouseService{}

// GetWarehouseList 获取仓库列表
func (r *WarehouseApi) GetWarehouseList(c *gin.Context) {
	var req systemReq.QueryWarehouseRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "查询仓库列表请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}

	if len(req.IDs) == 0 {
		ids, err := parseIds(c)
		if err != nil {
			systemRes.FailWithValidateMessage("参数错误: "+err.Error(), c)
			return
		}
		req.IDs = ids
	}

	list, total, err := warehouseService.GetWarehouseList(req, database.GetDB(c))
	if err != nil {
		utils.FailWithRequestLog(constant.LoggerChannelWork, "查询仓库列表异常", err, c, req)
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"code": 0,
		"data": gin.H{
			"list":      list,
			"total":     total,
			"page":      req.Page,
			"page_size": req.PageSize,
		},
		"msg": "查询成功",
	})
}

// GetWarehouseDetail 获取仓库详情
func (r *WarehouseApi) GetWarehouseDetail(c *gin.Context) {
	idStr := c.Param("id")

	if idStr == "" {
		utils.ErrorLog(constant.LoggerChannelRequest, logrus.Fields{
			"source":  "获取仓库详情请求参数异常",
			"err_msg": "ID参数不能为空",
		})
		systemRes.FailWithValidateMessage("参数错误: ID不能为空", c)
		return
	}

	var id int64
	if _, err := fmt.Sscanf(idStr, "%d", &id); err != nil || id <= 0 {
		utils.ErrorLog(constant.LoggerChannelRequest, logrus.Fields{
			"source":  "获取仓库详情请求参数异常",
			"err_msg": "ID格式错误: " + idStr,
		})
		systemRes.FailWithValidateMessage("参数错误: ID格式不正确", c)
		return
	}

	warehouse, err := warehouseService.GetWarehouseByID(id, database.GetDB(c))
	if err != nil {
		utils.FailWithRequestLog(constant.LoggerChannelWork, "查询仓库详情异常", err, c, gin.H{"id": id})
		return
	}

	systemRes.OkWithDetailed(warehouse, "查询成功", c)
}

// CreateWarehouse 创建仓库
func (r *WarehouseApi) CreateWarehouse(c *gin.Context) {
	var req systemReq.CreateWarehouseRequest
	if err := c.ShouldBind(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "创建仓库请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}

	userInfo := utils.GetUserInfo(c)
	id, err := warehouseService.CreateWarehouse(req, userInfo.AboutID, userInfo.Username, database.GetDB(c))
	if err != nil {
		utils.FailWithRequestLog(constant.LoggerChannelWork, "创建仓库异常", err, c, req)
		return
	}

	systemRes.OkWithDetailed(gin.H{"id": id}, "创建成功", c)
}

func (r *WarehouseApi) UpdateWarehouse(c *gin.Context) {
	var req systemReq.UpdateWarehouseRequest
	if err := c.ShouldBind(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "更新仓库请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}

	userInfo := utils.GetUserInfo(c)
	if err := warehouseService.UpdateWarehouse(req, userInfo.AboutID, userInfo.Username, database.GetDB(c)); err != nil {
		utils.FailWithRequestLog(constant.LoggerChannelWork, "更新仓库异常", err, c, req)
		return
	}

	systemRes.OkWithMessage("更新成功", c)
}

func (r *WarehouseApi) DeleteWarehouse(c *gin.Context) {
	var req systemReq.DeleteWarehouseRequest
	if err := c.ShouldBind(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "删除仓库请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}

	userInfo := utils.GetUserInfo(c)
	if err := warehouseService.DeleteWarehouse(req.ID, userInfo.AboutID, userInfo.Username, database.GetDB(c)); err != nil {
		utils.FailWithRequestLog(constant.LoggerChannelWork, "删除仓库异常", err, c, req)
		return
	}

	systemRes.OkWithMessage("删除成功", c)
}

// LocationToCsv 导出库位
func (r *LocationApi) LocationToCsv(c *gin.Context) {
	var req systemReq.ExportLocationRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "导出库位请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}

	result, err := locationService.ExportLocations(req, database.GetDB(c))
	if err != nil {
		utils.FailWithRequestLog(constant.LoggerChannelWork, "导出库位异常", err, c, req)
		return
	}

	systemRes.OkWithDetailed(result, "导出成功", c)
}

// CsvToLocation 导入库位
func (r *LocationApi) CsvToLocation(c *gin.Context) {
	var req systemReq.ImportLocationRequest
	if err := c.ShouldBind(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "导入库位请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}

	file, err := c.FormFile("file")
	if err != nil {
		systemRes.FailWithValidateMessage("请上传文件", c)
		return
	}

	if !strings.HasSuffix(strings.ToLower(file.Filename), ".xlsx") && !strings.HasSuffix(strings.ToLower(file.Filename), ".xls") {
		systemRes.FailWithValidateMessage("只支持Excel文件格式(.xlsx, .xls)", c)
		return
	}

	filePath := fmt.Sprintf("excel/import_%s_%d.xlsx", time.Now().Format("20060102150405"), time.Now().UnixNano())
	if err := c.SaveUploadedFile(file, filePath); err != nil {
		utils.FailWithRequestLog(constant.LoggerChannelWork, "保存上传文件异常", err, c, gin.H{"filename": file.Filename})
		return
	}

	defer func() {
		if err := os.Remove(filePath); err != nil {
			utils.ErrorLog(constant.LoggerChannelWork, logrus.Fields{
				"source":  "删除临时文件失败",
				"err_msg": err.Error(),
			})
		}
	}()

	result, err := locationService.ImportLocationsFromCSV(req, filePath, database.GetDB(c))
	if err != nil {
		utils.FailWithRequestLog(constant.LoggerChannelWork, "导入库位异常", err, c, gin.H{"filename": file.Filename})
		return
	}

	systemRes.OkWithDetailed(result, result.Message, c)
}

// GetUserWarehouseMappings 获取用户的仓库映射列表
func (r *WarehouseApi) GetUserWarehouseMappings(c *gin.Context) {
	data, err := warehouseService.GetUserWarehouseMappings()
	if err != nil {
		utils.FailWithRequestLog(constant.LoggerChannelWork, "获取用户的仓库映射列表异常", err, c, nil)
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"code": 0,
		"data": data,
		"msg":  "查询成功",
	})
}