审查视图

pkg/port/beego/controllers/web_client/excel_data_controller.go 14.3 KB
yangfu authored
1 2 3
package web_client

import (
yangfu authored
4
	"fmt"
5
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/port/beego/controllers"
yangfu authored
6
	"io"
7 8
	"strings"
tangxuhui authored
9 10
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/domain"
11
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/excelData/command"
yangfu authored
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

	"github.com/beego/beego/v2/server/web/context"
	"github.com/linmadan/egglib-go/utils/excel"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/excelData/query"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/excelData/service"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/allied_creation_cooperation"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/log"
)

type ExcelDataController struct {
	baseController
}

func (controller *ExcelDataController) responseExcelByFile(ctx *context.Context, excelExport *excel.ExcelExport, fileName string) error {
	ctx.Output.Header("Content-Disposition", "attachment; filename="+fileName)
	ctx.Output.Header("Content-Description", "File Transfer")
	ctx.Output.Header("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
	ctx.Output.Header("Content-Transfer-Encoding", "binary")
	ctx.Output.Header("Expires", "0")
	ctx.Output.Header("Cache-Control", "must-revalidate")
	ctx.Output.Header("Pragma", "public")
	//跳过保存文件,直接写入ctx.ResponseWriter
	excelExport.ExcelFile.Write(ctx.ResponseWriter)
	return nil
}
38 39 40 41 42 43 44 45 46 47 48
func (controller *ExcelDataController) fieldValueAllEmpty(param map[string]string) bool {
	isAllEmpty := true
	for _, v := range param {
		value := strings.TrimSpace(v)
		if len(value) > 0 {
			isAllEmpty = false
		}
	}
	return isAllEmpty
}
yangfu authored
49
// ImportDividendsOrder 导入分红订单
50
func (controller *ExcelDataController) ImportDividendsOrder() {
tangxuhui authored
51 52 53
	importDividendsOrder(controller)
}
54
func importDividendsOrder(controller *ExcelDataController) {
tangxuhui authored
55
tangxuhui authored
56
	fileReader, err := controller.GetExcelFile()
57 58 59 60 61
	if err != nil {
		controller.Response(nil, err)
		return
	}
	excelImport := excel.NewExcelImport()
Your Name authored
62
	excelImport.RowBegin = 3 //第3行开始读取
63
	excelImport.DataFields = []excel.DataField{
64 65
		{EnName: "OriginalOrderNum", CnName: "*来源单号"},
		{EnName: "DividendsCustomerName", CnName: "*客户名称"},
66 67
		{EnName: "OrderGoodName", CnName: "*产品名称"},
		{EnName: "OrderTime", CnName: "*订单日期"},
68
		{EnName: "RegionName", CnName: "*订单区域"},
69 70
		{EnName: "OrderGoodQuantity", CnName: "*产品数量"},
		{EnName: "OrderGoodPrice", CnName: "*产品价格"},
71
		{EnName: "Expense", CnName: "费用"},
yangfu authored
72
		{EnName: "CooperationContractNumber", CnName: "*项目合约编号"},
73
	}
tangxuhui authored
74
	excelData, err := excelImport.OpenExcelFromIoReader(fileReader)
75 76 77 78 79 80 81 82
	if err != nil {
		log.Logger.Error("解析excel文件失败," + err.Error())
		controller.Response(nil, err)
		return
	}
	//订单数据
	var returnedOrderData []allied_creation_cooperation.ImportDividendsOrderData
	for _, v := range excelData {
83 84
		if allEmpty := controller.fieldValueAllEmpty(v); allEmpty {
			//以全字段空跳过
tangxuhui authored
85
			break
86
		}
87 88
		//TODO 按需转化
		item := allied_creation_cooperation.ImportDividendsOrderData{
89 90 91 92 93 94 95 96 97
			OriginalOrderNum:          strings.TrimSpace(v["OriginalOrderNum"]),
			DividendsCustomerName:     strings.TrimSpace(v["DividendsCustomerName"]),
			OrderGoodName:             strings.TrimSpace(v["OrderGoodName"]),
			OrderTime:                 strings.TrimSpace(v["OrderTime"]),
			RegionName:                strings.TrimSpace(v["RegionName"]),
			OrderGoodQuantity:         strings.TrimSpace(v["OrderGoodQuantity"]),
			OrderGoodPrice:            strings.TrimSpace(v["OrderGoodPrice"]),
			Expense:                   strings.TrimSpace(v["Expense"]),
			CooperationContractNumber: strings.TrimSpace(v["CooperationContractNumber"]),
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
		}
		returnedOrderData = append(returnedOrderData, item)
	}
	creationCooperationGate := allied_creation_cooperation.NewHttplibAlliedCreationCooperation(controller.GetOperator())
	result, err := creationCooperationGate.ImportDividendsOrder(allied_creation_cooperation.ReqImportDividendsOrder{
		DividendsOrderData: returnedOrderData,
	})
	if err != nil {
		controller.Response(nil, err)
		return
	}
	controller.Response(result, nil)
}

// ImportDividendsReturnedOrder 导入分红退货单
113
func (controller *ExcelDataController) ImportDividendsReturnedOrder() {
tangxuhui authored
114 115 116
	importDividendsReturnedOrder(controller)
}
117
func importDividendsReturnedOrder(controller *ExcelDataController) {
tangxuhui authored
118
tangxuhui authored
119
	fileReader, err := controller.GetExcelFile()
yangfu authored
120 121 122 123 124
	if err != nil {
		controller.Response(nil, err)
		return
	}
	excelImport := excel.NewExcelImport()
yangfu authored
125
	excelImport.RowBegin = 3 //第2行表头开始读取
yangfu authored
126
	excelImport.DataFields = []excel.DataField{
127
		{EnName: "OriginalOrderNum", CnName: "*来源单号"},
yangfu authored
128 129 130 131
		{EnName: "DividendsReturnedCustomerName", CnName: "*客户名称"},
		{EnName: "OrderGoodName", CnName: "*产品名称"},
		{EnName: "DividendsReturnedDate", CnName: "*退货日期"},
		{EnName: "OrderTime", CnName: "*订单日期"},
132
		{EnName: "RegionName", CnName: "*退货区域"},
yangfu authored
133 134
		{EnName: "OrderGoodQuantity", CnName: "*退货数量"},
		{EnName: "OrderGoodPrice", CnName: "*退货价格"},
135
		{EnName: "CooperationContractNumber", CnName: "*项目合约编号"},
yangfu authored
136
	}
tangxuhui authored
137
	excelData, err := excelImport.OpenExcelFromIoReader(fileReader)
yangfu authored
138 139 140 141 142 143 144 145
	if err != nil {
		log.Logger.Error("解析excel文件失败," + err.Error())
		controller.Response(nil, err)
		return
	}
	//退货单数据
	returnedOrderData := []allied_creation_cooperation.ImportDividendsReturnedOrderData{}
	for _, v := range excelData {
146 147
		if allEmpty := controller.fieldValueAllEmpty(v); allEmpty {
			//以全字段空跳过
tangxuhui authored
148
			break
149
		}
yangfu authored
150 151
		//TODO 按需转化
		item := allied_creation_cooperation.ImportDividendsReturnedOrderData{
152 153 154 155 156 157 158 159 160
			OriginalOrderNum:              strings.TrimSpace(v["OriginalOrderNum"]),
			DividendsReturnedCustomerName: strings.TrimSpace(v["DividendsReturnedCustomerName"]),
			OrderGoodName:                 strings.TrimSpace(v["OrderGoodName"]),
			DividendsReturnedDate:         strings.TrimSpace(v["DividendsReturnedDate"]),
			OrderTime:                     strings.TrimSpace(v["OrderTime"]),
			RegionName:                    strings.TrimSpace(v["RegionName"]),
			OrderGoodQuantity:             strings.TrimSpace(v["OrderGoodQuantity"]),
			OrderGoodPrice:                strings.TrimSpace(v["OrderGoodPrice"]),
			CooperationContractNumber:     strings.TrimSpace(v["CooperationContractNumber"]),
yangfu authored
161 162 163 164 165 166 167 168 169 170 171 172 173 174
		}
		returnedOrderData = append(returnedOrderData, item)
	}
	creationCooperationGate := allied_creation_cooperation.NewHttplibAlliedCreationCooperation(controller.GetOperator())
	result, err := creationCooperationGate.ImportDividendsReturnedOrder(allied_creation_cooperation.ReqImportDividendsReturnedOrder{
		DividendsReturnedOrderData: returnedOrderData,
	})
	if err != nil {
		controller.Response(nil, err)
		return
	}
	controller.Response(result, nil)
}
yangfu authored
175
// FileImport 文件导入
176
func (controller *ExcelDataController) FileImport() {
yangfu authored
177 178 179 180 181 182 183 184
	code := controller.GetString("code")
	switch code {
	case domain.ImportDividendsOrders:
		importDividendsOrder(controller)
	case domain.ImportDividendsReturnOrders:
		importDividendsReturnedOrder(controller)
	default:
		defaultImport(controller)
yangfu authored
185 186
	}
}
yangfu authored
187
188
func defaultImport(controller *ExcelDataController) {
yangfu authored
189
	var (
190 191 192 193
		data     interface{}
		err      error
		r        io.Reader
		ext      string
庄敏学 authored
194
		fileName string
yangfu authored
195
	)
yangfu authored
196
	excelService := service.NewExcelDataService(nil)
197
	r, ext, fileName, err = controller.GetFileWithExt()
yangfu authored
198 199 200 201 202
	if err != nil {
		controller.Response(nil, err)
		return
	}
	cmd := &command.ImportDataCommand{}
yangfu authored
203
	controller.ParseForm(cmd)
yangfu authored
204 205
	cmd.Operator = controller.GetOperator()
	cmd.Reader = r
206
	cmd.FileExt = ext
庄敏学 authored
207
	cmd.FileName = fileName
yangfu authored
208
	switch cmd.Code {
yangfu authored
209
	case domain.ImportCompanyUser:
yangfu authored
210
		data, err = excelService.ImportCompanyUser(cmd)
tangxuhui authored
211
	case domain.ImportCooperationUser:
yangfu authored
212
		data, err = excelService.ImportCooperationUser(cmd)
yangfu authored
213
	case domain.ImportOrganization:
yangfu authored
214
		data, err = excelService.ImportOrganization(cmd)
215 216
	case domain.ImportProducts:
		data, err = excelService.ImportProduct(cmd)
yangfu authored
217 218
	case domain.ImportDevices:
		data, err = excelService.ImportDevice(cmd)
庄敏学 authored
219
	case domain.ImportCosts:
220
		data, err = excelService.ImportCost(cmd)
yangfu authored
221 222
	default:
		err = fmt.Errorf("导入不存在 Code:%v", cmd.Code)
yangfu authored
223
	}
yangfu authored
224
	controller.Response(data, err)
yangfu authored
225
}
yangfu authored
226
227
func (controller *ExcelDataController) FileImportTemplate() {
yangfu authored
228 229 230 231 232 233 234 235
	excelService := service.NewExcelDataService(nil)
	cmd := &command.ImportDataCommand{}
	code := controller.GetString(":code")
	cmd.Code = code
	var data interface{}
	data, err := excelService.FileImportTemplate(cmd)
	controller.Response(data, err)
}
yangfu authored
236 237

// FileExport 文件导出
238
func (controller *ExcelDataController) FileExport() {
yangfu authored
239 240 241
	fileExport(controller, "")
}
242
func fileExport(controller *ExcelDataController, code string) {
yangfu authored
243 244 245 246 247 248 249 250 251 252
	// 1.读取command
	exportDataCommand := &command.ExportDataCommand{}
	err := controller.Unmarshal(exportDataCommand)
	if err != nil {
		log.Logger.Debug("json err:" + err.Error())
		controller.Response(nil, err)
		return
	}
	exportDataCommand.Operator = controller.GetOperator()
yangfu authored
253 254 255
	if exportDataCommand.Code == "" && code != "" {
		exportDataCommand.Code = code
	}
yangfu authored
256 257 258 259 260
	// 2.读取data
	var data excel.ExcelMaker
	var filename string
	var excelService = service.NewExcelDataService(nil)
	switch exportDataCommand.Code {
yangfu authored
261
	case domain.ExportCompanyUser:
yangfu authored
262 263 264 265 266
		companyUserListQuery := &query.CompanyUserListQuery{}
		exportDataCommand.UnmarshalQuery(companyUserListQuery)
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportCompanyUser(companyUserListQuery)
		filename = "导出公司用户"
yangfu authored
267 268 269 270 271 272
	case domain.ExportCooperationUser:
		companyUserListQuery := &query.CooperationUserListQuery{}
		exportDataCommand.UnmarshalQuery(companyUserListQuery)
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportCooperationUser(companyUserListQuery)
		filename = "导出共创用户"
273 274 275 276 277 278
	case domain.ExportProducts:
		companyUserListQuery := &query.SearchProductQuery{}
		exportDataCommand.UnmarshalQuery(companyUserListQuery)
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportProducts(companyUserListQuery)
		filename = "导出商品"
279 280 281 282 283 284 285 286 287 288 289 290
	case domain.ExportManufactureEmployeeProductive:
		companyUserListQuery := &query.ManufactureEmployeeProductiveQuery{}
		exportDataCommand.UnmarshalQuery(companyUserListQuery)
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportEmployeeProductive(companyUserListQuery)
		filename = "导出员工产能统计"
	case domain.ExportManufactureWorkshopProductive:
		companyUserListQuery := &query.ManufactureWorkshopProductiveQuery{}
		exportDataCommand.UnmarshalQuery(companyUserListQuery)
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportWorkshopProductive(companyUserListQuery)
		filename = "导出车间产能汇总"
291 292 293 294 295 296 297 298 299 300 301 302
	case domain.ExportManufactureEmployeeAttendanceStatics:
		companyUserListQuery := &query.ManufactureExportEmployeeAttendanceStaticsQuery{}
		controllers.Must(exportDataCommand.UnmarshalQuery(companyUserListQuery))
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportEmployeeAttendanceStatics(companyUserListQuery)
		filename = "导出员工工时统计"
	case domain.ExportManufactureWorkshopAttendanceStatics:
		companyUserListQuery := &query.ManufactureExportWorkshopAttendanceStaticsQuery{}
		controllers.Must(exportDataCommand.UnmarshalQuery(companyUserListQuery))
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportWorkshopAttendanceStatics(companyUserListQuery)
		filename = "导出车间工时汇总"
303 304 305 306 307 308 309

	case domain.ExportCostStructuredDailyFillingAbnormalLog:
		query := &query.CostDailyFillingAbnormalLogQuery{}
		controllers.Must(exportDataCommand.UnmarshalQuery(query))
		query.Operator = exportDataCommand.Operator
		data, err = excelService.ExportDailyFillingAbnormalLog(query)
		filename = "异常记录"
yangfu authored
310 311
	default:
		err = fmt.Errorf("export type :%v not exists", exportDataCommand.Code)
yangfu authored
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
	}
	if err != nil {
		log.Logger.Debug("excelService.Export err:" + err.Error())
		controller.Response(nil, err)
		return
	}

	// 3.返回文件
	excelTool := excel.NewExcelExport()
	err = excelTool.ExportData(data, "")
	if err != nil {
		log.Logger.Debug("excelTool.ExportData err:" + err.Error())
		controller.Response(nil, err)
		return
	}
	controller.responseExcelByFile(controller.Ctx, excelTool, filename)
}
yangfu authored
329 330

// ExportCompanyUser 导出公司用户
331
func (controller *ExcelDataController) ExportCompanyUser() {
yangfu authored
332 333 334 335
	fileExport(controller, domain.ExportCompanyUser)
}

// ExportCooperationUser 导出共创用户
336
func (controller *ExcelDataController) ExportCooperationUser() {
yangfu authored
337 338
	fileExport(controller, domain.ExportCooperationUser)
}
339
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
// ExportProducts 导出生产制造产品
func (controller *ExcelDataController) ExportProducts() {
	fileExport(controller, domain.ExportProducts)
}

// ExportManufactureEmployeeProductive 导出生产制造-员工产能统计
func (controller *ExcelDataController) ExportManufactureEmployeeProductive() {
	fileExport(controller, domain.ExportManufactureEmployeeProductive)
}

// ExportManufactureEmployeeProductive 导出生产制造-车间产能统计
func (controller *ExcelDataController) ExportManufactureWorkshopProductive() {
	fileExport(controller, domain.ExportManufactureWorkshopProductive)
}
355 356 357 358 359 360 361 362 363 364
// ExportManufactureEmployeeAttendanceStatics 导出生产制造-员工工时统计
func (controller *ExcelDataController) ExportManufactureEmployeeAttendanceStatics() {
	fileExport(controller, domain.ExportManufactureEmployeeAttendanceStatics)
}

// ExportManufactureWorkshopAttendanceStatics 导出生产制造-车间工时统计
func (controller *ExcelDataController) ExportManufactureWorkshopAttendanceStatics() {
	fileExport(controller, domain.ExportManufactureWorkshopAttendanceStatics)
}
365 366 367 368
func (controller *ExcelDataController) ExportCostStructuredDailyFillingAbnormalLog() {
	fileExport(controller, domain.ExportCostStructuredDailyFillingAbnormalLog)
}
369 370
//GetExcelDataFields 获取导出excel数据的可选字段
func (controller *ExcelDataController) GetExcelDataFields() {
tangxuhui authored
371 372 373 374
	code := controller.GetString(":code")
	var excelService = service.NewExcelDataService(nil)
	data, _ := excelService.GetExcelDataFields(&query.ExcelDataFieldsQuery{Code: code})
	controller.Response(data, nil)
375
}