Teams/shgx_tz_mes_backend_sync
3
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

后道

Browse Source
This commit is contained in:
赵正易
2025-05-07 08:20:08 +08:00
parent 99a74fa5db
commit 4d1ec06430
99 changed files with 4397 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
ZR.Admin.WebApi/Controllers/mes/qc/backend/QcBackEndBaseDefectController.cs Normal file
View File

@@ -0,0 +1,100 @@
using Microsoft.AspNetCore.Mvc;
using ZR.Model.Dto;
using ZR.Model.Business;
using ZR.Service.Business.IBusinessService;
using ZR.Admin.WebApi.Extensions;
using ZR.Admin.WebApi.Filters;
//创建时间：2025-01-02
namespace ZR.Admin.WebApi.Controllers
{
/// <summary>
/// 质量BackEnd基础缺陷项
/// </summary>
[Verify]
[Route("/mes/qc/BackEnd/QcBackEndBaseDefect")]
public class QcBackEndBaseDefectController : BaseController
{
/// <summary>
/// 质量BackEnd基础缺陷项接口
/// </summary>
private readonly IQcBackEndBaseDefectService _QcBackEndBaseDefectService;
public QcBackEndBaseDefectController(IQcBackEndBaseDefectService QcBackEndBaseDefectService)
{
_QcBackEndBaseDefectService = QcBackEndBaseDefectService;
}
/// <summary>
/// 查询质量BackEnd基础缺陷项列表
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
[HttpGet("list")]
public IActionResult QueryQcBackEndBaseDefect([FromQuery] QcBackEndBaseDefectQueryDto parm)
{
var response = _QcBackEndBaseDefectService.GetList(parm);
return SUCCESS(response);
}
/// <summary>
/// 查询质量BackEnd基础缺陷项详情
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
[HttpGet("{Id}")]
public IActionResult GetQcBackEndBaseDefect(int Id)
{
var response = _QcBackEndBaseDefectService.GetInfo(Id);
var info = response.Adapt<QcBackEndBaseDefect>();
return SUCCESS(info);
}
/// <summary>
/// 添加质量BackEnd基础缺陷项
/// </summary>
/// <returns></returns>
[HttpPost]
[Log(Title = "质量BackEnd基础缺陷项", BusinessType = BusinessType.INSERT)]
public IActionResult AddQcBackEndBaseDefect([FromBody] QcBackEndBaseDefectDto parm)
{
var modal = parm.Adapt<QcBackEndBaseDefect>().ToCreate(HttpContext);
var response = _QcBackEndBaseDefectService.AddQcBackEndBaseDefect(modal);
return SUCCESS(response);
}
/// <summary>
/// 更新质量BackEnd基础缺陷项
/// </summary>
/// <returns></returns>
[HttpPut]
[Log(Title = "质量BackEnd基础缺陷项", BusinessType = BusinessType.UPDATE)]
public IActionResult UpdateQcBackEndBaseDefect([FromBody] QcBackEndBaseDefectDto parm)
{
var modal = parm.Adapt<QcBackEndBaseDefect>().ToUpdate(HttpContext);
var response = _QcBackEndBaseDefectService.UpdateQcBackEndBaseDefect(modal);
return ToResponse(response);
}
/// <summary>
/// 删除质量BackEnd基础缺陷项
/// </summary>
/// <returns></returns>
[HttpDelete("{ids}")]
[Log(Title = "质量BackEnd基础缺陷项", BusinessType = BusinessType.DELETE)]
public IActionResult DeleteQcBackEndBaseDefect(string ids)
{
int[] idsArr = Tools.SpitIntArrary(ids);
if (idsArr.Length <= 0) { return ToResponse(ApiResult.Error($"删除失败Id 不能为空")); }
var response = _QcBackEndBaseDefectService.Delete(idsArr);
return ToResponse(response);
}
}
}

100
ZR.Admin.WebApi/Controllers/mes/qc/backend/QcBackEndBaseGroupController.cs Normal file
View File

@@ -0,0 +1,100 @@
using Microsoft.AspNetCore.Mvc;
using ZR.Model.Dto;
using ZR.Model.Business;
using ZR.Service.Business.IBusinessService;
using ZR.Admin.WebApi.Extensions;
using ZR.Admin.WebApi.Filters;
//创建时间：2025-01-02
namespace ZR.Admin.WebApi.Controllers
{
/// <summary>
/// 质量BackEnd班组
/// </summary>
[Verify]
[Route("/mes/qc/BackEnd/QcBackEndBaseGroup")]
public class QcBackEndBaseGroupController : BaseController
{
/// <summary>
/// 质量BackEnd班组接口
/// </summary>
private readonly IQcBackEndBaseGroupService _QcBackEndBaseGroupService;
public QcBackEndBaseGroupController(IQcBackEndBaseGroupService QcBackEndBaseGroupService)
{
_QcBackEndBaseGroupService = QcBackEndBaseGroupService;
}
/// <summary>
/// 查询质量BackEnd班组列表
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
[HttpGet("list")]
public IActionResult QueryQcBackEndBaseGroup([FromQuery] QcBackEndBaseGroupQueryDto parm)
{
var response = _QcBackEndBaseGroupService.GetList(parm);
return SUCCESS(response);
}
/// <summary>
/// 查询质量BackEnd班组详情
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
[HttpGet("{Id}")]
public IActionResult GetQcBackEndBaseGroup(int Id)
{
var response = _QcBackEndBaseGroupService.GetInfo(Id);
var info = response.Adapt<QcBackEndBaseGroup>();
return SUCCESS(info);
}
/// <summary>
/// 添加质量BackEnd班组
/// </summary>
/// <returns></returns>
[HttpPost]
[Log(Title = "质量BackEnd班组", BusinessType = BusinessType.INSERT)]
public IActionResult AddQcBackEndBaseGroup([FromBody] QcBackEndBaseGroupDto parm)
{
var modal = parm.Adapt<QcBackEndBaseGroup>().ToCreate(HttpContext);
var response = _QcBackEndBaseGroupService.AddQcBackEndBaseGroup(modal);
return SUCCESS(response);
}
/// <summary>
/// 更新质量BackEnd班组
/// </summary>
/// <returns></returns>
[HttpPut]
[Log(Title = "质量BackEnd班组", BusinessType = BusinessType.UPDATE)]
public IActionResult UpdateQcBackEndBaseGroup([FromBody] QcBackEndBaseGroupDto parm)
{
var modal = parm.Adapt<QcBackEndBaseGroup>().ToUpdate(HttpContext);
var response = _QcBackEndBaseGroupService.UpdateQcBackEndBaseGroup(modal);
return ToResponse(response);
}
/// <summary>
/// 删除质量BackEnd班组
/// </summary>
/// <returns></returns>
[HttpDelete("{ids}")]
[Log(Title = "质量BackEnd班组", BusinessType = BusinessType.DELETE)]
public IActionResult DeleteQcBackEndBaseGroup(string ids)
{
int[] idsArr = Tools.SpitIntArrary(ids);
if (idsArr.Length <= 0) { return ToResponse(ApiResult.Error($"删除失败Id 不能为空")); }
var response = _QcBackEndBaseGroupService.Delete(idsArr);
return ToResponse(response);
}
}
}

104
ZR.Admin.WebApi/Controllers/mes/qc/backend/QcBackEndBaseLabelAnalysisController.cs Normal file
View File

@@ -0,0 +1,104 @@
using Microsoft.AspNetCore.Mvc;
using ZR.Model.Dto;
using ZR.Model.Business;
using ZR.Service.Business.IBusinessService;
using ZR.Admin.WebApi.Extensions;
using ZR.Admin.WebApi.Filters;
//创建时间：2025-01-02
namespace ZR.Admin.WebApi.Controllers
{
/// <summary>
/// 质量BackEnd基础标签解析
/// </summary>
[Verify]
[Route("/mes/qc/BackEnd/QcBackEndBaseLabelAnalysis")]
public class QcBackEndBaseLabelAnalysisController : BaseController
{
/// <summary>
/// 质量BackEnd基础标签解析接口
/// </summary>
private readonly IQcBackEndBaseLabelAnalysisService _QcBackEndBaseLabelAnalysisService;
public QcBackEndBaseLabelAnalysisController(IQcBackEndBaseLabelAnalysisService QcBackEndBaseLabelAnalysisService)
{
_QcBackEndBaseLabelAnalysisService = QcBackEndBaseLabelAnalysisService;
}
/// <summary>
/// 查询质量BackEnd基础标签解析列表
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
[HttpGet("list")]
public IActionResult QueryQcBackEndBaseLabelAnalysis([FromQuery] QcBackEndBaseLabelAnalysisQueryDto parm)
{
var response = _QcBackEndBaseLabelAnalysisService.GetList(parm);
return SUCCESS(response);
}
/// <summary>
/// 查询质量BackEnd基础标签解析详情
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
[HttpGet("{Id}")]
public IActionResult GetQcBackEndBaseLabelAnalysis(int Id)
{
var response = _QcBackEndBaseLabelAnalysisService.GetInfo(Id);
var info = response.Adapt<QcBackEndBaseLabelAnalysis>();
return SUCCESS(info);
}
/// <summary>
/// 添加质量BackEnd基础标签解析
/// </summary>
/// <returns></returns>
[HttpPost]
[Log(Title = "质量BackEnd基础标签解析", BusinessType = BusinessType.INSERT)]
public IActionResult AddQcBackEndBaseLabelAnalysis([FromBody] QcBackEndBaseLabelAnalysisDto parm)
{
var modal = parm.Adapt<QcBackEndBaseLabelAnalysis>().ToCreate(HttpContext);
var response = _QcBackEndBaseLabelAnalysisService.AddQcBackEndBaseLabelAnalysis(modal);
return SUCCESS(response);
}
/// <summary>
/// 更新质量BackEnd基础标签解析
/// </summary>
/// <returns></returns>
[HttpPut]
[Log(Title = "质量BackEnd基础标签解析", BusinessType = BusinessType.UPDATE)]
public IActionResult UpdateQcBackEndBaseLabelAnalysis([FromBody] QcBackEndBaseLabelAnalysisDto parm)
{
var modal = parm.Adapt<QcBackEndBaseLabelAnalysis>().ToUpdate(HttpContext);
var response = _QcBackEndBaseLabelAnalysisService.UpdateQcBackEndBaseLabelAnalysis(modal);
return ToResponse(response);
}
/// <summary>
/// 删除质量BackEnd基础标签解析
/// </summary>
/// <returns></returns>
[HttpDelete("{ids}")]
[Log(Title = "质量BackEnd基础标签解析", BusinessType = BusinessType.DELETE)]
public IActionResult DeleteQcBackEndBaseLabelAnalysis(string ids)
{
int[] idsArr = Tools.SpitIntArrary(ids);
if (idsArr.Length <= 0) { return ToResponse(ApiResult.Error($"删除失败Id 不能为空")); }
var response = _QcBackEndBaseLabelAnalysisService.Delete(idsArr);
return ToResponse(response);
}
}
}

104
ZR.Admin.WebApi/Controllers/mes/qc/backend/QcBackEndBaseSiteController.cs Normal file
View File

@@ -0,0 +1,104 @@
using Microsoft.AspNetCore.Mvc;
using ZR.Model.Dto;
using ZR.Model.Business;
using ZR.Service.Business.IBusinessService;
using ZR.Admin.WebApi.Extensions;
using ZR.Admin.WebApi.Filters;
//创建时间：2025-01-02
namespace ZR.Admin.WebApi.Controllers
{
/// <summary>
/// 质量BackEnd基础站点
/// </summary>
[Verify]
[Route("/mes/qc/BackEnd/QcBackEndBaseSite")]
public class QcBackEndBaseSiteController : BaseController
{
/// <summary>
/// 质量BackEnd基础站点接口
/// </summary>
private readonly IQcBackEndBaseSiteService _QcBackEndBaseSiteService;
public QcBackEndBaseSiteController(IQcBackEndBaseSiteService QcBackEndBaseSiteService)
{
_QcBackEndBaseSiteService = QcBackEndBaseSiteService;
}
/// <summary>
/// 查询质量BackEnd基础站点列表
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
[HttpGet("list")]
public IActionResult QueryQcBackEndBaseSite([FromQuery] QcBackEndBaseSiteQueryDto parm)
{
var response = _QcBackEndBaseSiteService.GetList(parm);
return SUCCESS(response);
}
/// <summary>
/// 查询质量BackEnd基础站点详情
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
[HttpGet("{Id}")]
public IActionResult GetQcBackEndBaseSite(int Id)
{
var response = _QcBackEndBaseSiteService.GetInfo(Id);
var info = response.Adapt<QcBackEndBaseSite>();
return SUCCESS(info);
}
/// <summary>
/// 添加质量BackEnd基础站点
/// </summary>
/// <returns></returns>
[HttpPost]
[Log(Title = "质量BackEnd基础站点", BusinessType = BusinessType.INSERT)]
public IActionResult AddQcBackEndBaseSite([FromBody] QcBackEndBaseSiteDto parm)
{
var modal = parm.Adapt<QcBackEndBaseSite>().ToCreate(HttpContext);
var response = _QcBackEndBaseSiteService.AddQcBackEndBaseSite(modal);
return SUCCESS(response);
}
/// <summary>
/// 更新质量BackEnd基础站点
/// </summary>
/// <returns></returns>
[HttpPut]
[Log(Title = "质量BackEnd基础站点", BusinessType = BusinessType.UPDATE)]
public IActionResult UpdateQcBackEndBaseSite([FromBody] QcBackEndBaseSiteDto parm)
{
var modal = parm.Adapt<QcBackEndBaseSite>().ToUpdate(HttpContext);
var response = _QcBackEndBaseSiteService.UpdateQcBackEndBaseSite(modal);
return ToResponse(response);
}
/// <summary>
/// 删除质量BackEnd基础站点
/// </summary>
/// <returns></returns>
[HttpDelete("{ids}")]
[Log(Title = "质量BackEnd基础站点", BusinessType = BusinessType.DELETE)]
public IActionResult DeleteQcBackEndBaseSite(string ids)
{
int[] idsArr = Tools.SpitIntArrary(ids);
if (idsArr.Length <= 0) { return ToResponse(ApiResult.Error($"删除失败Id 不能为空")); }
var response = _QcBackEndBaseSiteService.Delete(idsArr);
return ToResponse(response);
}
}
}

203
ZR.Admin.WebApi/Controllers/mes/qc/backend/QcBackEndController.cs Normal file
View File

@@ -0,0 +1,203 @@
using Microsoft.AspNetCore.Mvc;
using ZR.Admin.WebApi.Extensions;
using ZR.Admin.WebApi.Filters;
using ZR.Model.Business;
using ZR.Model.Dto;
using ZR.Service.Business.IBusinessService;
//创建时间：2025-01-02
namespace ZR.Admin.WebApi.Controllers
{
/// <summary>
/// 质量BackEnd业务模块
/// </summary>
[Route("/mes/qc/BackEnd/QcBackEndController")]
public class QcBackEndController : BaseController
{
/// <summary>
/// 质量BackEnd业务模块接口
/// </summary>
private readonly IQcBackEndService _QcBackEndService;
public QcBackEndController(IQcBackEndService QcBackEndService)
{
_QcBackEndService = QcBackEndService;
}
/// <summary>
/// 获取班组下拉
/// </summary>
/// <returns></returns>
[HttpGet("GetGroupOptions")]
[AllowAnonymous]
public IActionResult GetGroupOptions()
{
var response = _QcBackEndService.GetGroupOptions();
return SUCCESS(response);
}
/// <summary>
/// 获取站点下拉
/// </summary>
/// <returns></returns>
[HttpGet("GetStieOptions")]
[AllowAnonymous]
public IActionResult GetStieOptions()
{
var response = _QcBackEndService.GetStieOptions();
return SUCCESS(response);
}
/// <summary>
/// 获取缺陷项初始数据
/// </summary>
/// <returns></returns>
[HttpGet("GetDefectInitOptions")]
[AllowAnonymous]
public IActionResult GetDefectInitOptions()
{
var response = _QcBackEndService.GetDefectInitOptions();
return SUCCESS(response);
}
/// <summary>
/// 获取缺陷项列表初始数据
/// </summary>
/// <returns></returns>
[HttpGet("GetDefectTableOptions")]
[AllowAnonymous]
public IActionResult GetDefectTableOptions()
{
var response = _QcBackEndService.GetDefectTableOptions();
return SUCCESS(response);
}
/// <summary>
/// 解析标签
/// </summary>
/// <param name="label">标签内容</param>
/// <param name="type">解析方式</param>
/// <returns></returns>
[HttpGet("AnalyzeLabel")]
[AllowAnonymous]
public IActionResult AnalyzeLabel(string label, int type)
{
var response = _QcBackEndService.AnalyzeLabelToDto(label, type);
return SUCCESS(response);
}
/// <summary>
/// 开始工单
/// </summary>
/// <returns></returns>
[HttpPost("StartBackEndWorkOrder")]
[AllowAnonymous]
public IActionResult StartBackEndWorkOrder([FromBody] QcBackEndWorkorderDetailDto parm)
{
var modal = parm.Adapt<QcBackEndWorkorderDetailDto>().ToCreate(HttpContext);
var response = _QcBackEndService.StartBackEndWorkOrder(modal);
return SUCCESS(response);
}
/// <summary>
/// 修改缺陷项
/// </summary>
/// <returns></returns>
[HttpPost("ChangeWorkOrderDefect")]
[AllowAnonymous]
public IActionResult StartBackEndWorkOrder([FromBody] QcBackEndWorkorderDefectDto parm)
{
var modal = parm.Adapt<QcBackEndWorkorderDefectDto>().ToCreate(HttpContext);
var response = _QcBackEndService.ChangeWorkOrderDefect(modal);
return SUCCESS(response);
}
/// <summary>
/// 获取工单缺陷项
/// </summary>
/// <returns></returns>
[HttpGet("GetWorkOrderDefectList")]
[AllowAnonymous]
public IActionResult GetWorkOrderDefectList(string workOrder)
{
var response = _QcBackEndService.GetWorkOrderDefectList(workOrder);
return SUCCESS(response);
}
/// <summary>
/// 扫描内标签,添加标签记录
/// </summary>
/// <returns></returns>
[HttpPost("ScanInnerLabel")]
[AllowAnonymous]
public IActionResult ScanInnerLabel([FromBody] QcBackEndLabelScanDto parm)
{
try
{
var modal = parm.Adapt<QcBackEndLabelScanDto>().ToCreate(HttpContext);
var response = _QcBackEndService.ScanInnerLabel(modal);
return SUCCESS(response);
}catch(Exception ex)
{
return SUCCESS("请刷新页面,错误代码:" + ex.Message);
}
}
/// <summary>
/// 结束工单，并生成质量报表
/// </summary>
/// <returns></returns>
[HttpGet("EndBackEndWorkOrderAndCreateStatistics")]
[AllowAnonymous]
public IActionResult EndBackEndWorkOrderAndCreateStatistics(string workOrder)
{
var response = _QcBackEndService.EndBackEndWorkOrderAndCreateStatistics(workOrder);
return SUCCESS(response);
}
/// <summary>
/// 更新工单相关信息
/// </summary>
/// <returns></returns>
[HttpGet("UpdateWorkOrderDetail")]
[AllowAnonymous]
public IActionResult UpdateWorkOrderDetail(string workOrder)
{
var response = _QcBackEndService.UpdateWorkOrderDetail(workOrder);
return SUCCESS(response);
}
/// <summary>
/// 自动生成标签记录
/// </summary>
/// <returns></returns>
[HttpPost("GenerateVirtualLabel")]
[AllowAnonymous]
public IActionResult GenerateVirtualLabel([FromBody] QcBackEndWorkorderDetailDto parm)
{
try
{
var modal = parm.Adapt<QcBackEndWorkorderDetailDto>().ToCreate(HttpContext);
var response = _QcBackEndService.GenerateVirtualLabel(modal);
return SUCCESS(response);
}
catch (Exception ex)
{
return ToResponse(ApiResult.Error(ex.Message));
}
}
}
}

100
ZR.Admin.WebApi/Controllers/mes/qc/backend/QcBackEndLogWorkorderController.cs Normal file
View File

@@ -0,0 +1,100 @@
using Microsoft.AspNetCore.Mvc;
using ZR.Model.Dto;
using ZR.Model.Business;
using ZR.Service.Business.IBusinessService;
using ZR.Admin.WebApi.Extensions;
using ZR.Admin.WebApi.Filters;
//创建时间：2025-01-02
namespace ZR.Admin.WebApi.Controllers
{
/// <summary>
/// 质量BackEnd工单操作日志
/// </summary>
[Verify]
[Route("/mes/qc/BackEnd/QcBackEndLogWorkorder")]
public class QcBackEndLogWorkorderController : BaseController
{
/// <summary>
/// 质量BackEnd工单操作日志接口
/// </summary>
private readonly IQcBackEndLogWorkorderService _QcBackEndLogWorkorderService;
public QcBackEndLogWorkorderController(IQcBackEndLogWorkorderService QcBackEndLogWorkorderService)
{
_QcBackEndLogWorkorderService = QcBackEndLogWorkorderService;
}
/// <summary>
/// 查询质量BackEnd工单操作日志列表
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
[HttpGet("list")]
public IActionResult QueryQcBackEndLogWorkorder([FromQuery] QcBackEndLogWorkorderQueryDto parm)
{
var response = _QcBackEndLogWorkorderService.GetList(parm);
return SUCCESS(response);
}
/// <summary>
/// 查询质量BackEnd工单操作日志详情
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
[HttpGet("{Id}")]
public IActionResult GetQcBackEndLogWorkorder(string Id)
{
var response = _QcBackEndLogWorkorderService.GetInfo(Id);
var info = response.Adapt<QcBackEndLogWorkorder>();
return SUCCESS(info);
}
/// <summary>
/// 添加质量BackEnd工单操作日志
/// </summary>
/// <returns></returns>
[HttpPost]
[Log(Title = "质量BackEnd工单操作日志", BusinessType = BusinessType.INSERT)]
public IActionResult AddQcBackEndLogWorkorder([FromBody] QcBackEndLogWorkorderDto parm)
{
var modal = parm.Adapt<QcBackEndLogWorkorder>().ToCreate(HttpContext);
var response = _QcBackEndLogWorkorderService.AddQcBackEndLogWorkorder(modal);
return SUCCESS(response);
}
/// <summary>
/// 更新质量BackEnd工单操作日志
/// </summary>
/// <returns></returns>
[HttpPut]
[Log(Title = "质量BackEnd工单操作日志", BusinessType = BusinessType.UPDATE)]
public IActionResult UpdateQcBackEndLogWorkorder([FromBody] QcBackEndLogWorkorderDto parm)
{
var modal = parm.Adapt<QcBackEndLogWorkorder>().ToUpdate(HttpContext);
var response = _QcBackEndLogWorkorderService.UpdateQcBackEndLogWorkorder(modal);
return ToResponse(response);
}
/// <summary>
/// 删除质量BackEnd工单操作日志
/// </summary>
/// <returns></returns>
[HttpDelete("{ids}")]
[Log(Title = "质量BackEnd工单操作日志", BusinessType = BusinessType.DELETE)]
public IActionResult DeleteQcBackEndLogWorkorder(string ids)
{
int[] idsArr = Tools.SpitIntArrary(ids);
if (idsArr.Length <= 0) { return ToResponse(ApiResult.Error($"删除失败Id 不能为空")); }
var response = _QcBackEndLogWorkorderService.Delete(idsArr);
return ToResponse(response);
}
}
}

100
ZR.Admin.WebApi/Controllers/mes/qc/backend/QcBackEndRecordLabelScanController.cs Normal file
View File

@@ -0,0 +1,100 @@
using Microsoft.AspNetCore.Mvc;
using ZR.Model.Dto;
using ZR.Model.Business;
using ZR.Service.Business.IBusinessService;
using ZR.Admin.WebApi.Extensions;
using ZR.Admin.WebApi.Filters;
//创建时间：2025-01-02
namespace ZR.Admin.WebApi.Controllers
{
/// <summary>
/// 质量BackEnd扫码标签记录
/// </summary>
[Verify]
[Route("/mes/qc/BackEnd/QcBackEndRecordLabelScan")]
public class QcBackEndRecordLabelScanController : BaseController
{
/// <summary>
/// 质量BackEnd扫码标签记录接口
/// </summary>
private readonly IQcBackEndRecordLabelScanService _QcBackEndRecordLabelScanService;
public QcBackEndRecordLabelScanController(IQcBackEndRecordLabelScanService QcBackEndRecordLabelScanService)
{
_QcBackEndRecordLabelScanService = QcBackEndRecordLabelScanService;
}
/// <summary>
/// 查询质量BackEnd扫码标签记录列表
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
[HttpGet("list")]
public IActionResult QueryQcBackEndRecordLabelScan([FromQuery] QcBackEndRecordLabelScanQueryDto parm)
{
var response = _QcBackEndRecordLabelScanService.GetList(parm);
return SUCCESS(response);
}
/// <summary>
/// 查询质量BackEnd扫码标签记录详情
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
[HttpGet("{Id}")]
public IActionResult GetQcBackEndRecordLabelScan(string Id)
{
var response = _QcBackEndRecordLabelScanService.GetInfo(Id);
var info = response.Adapt<QcBackEndRecordLabelScan>();
return SUCCESS(info);
}
/// <summary>
/// 添加质量BackEnd扫码标签记录
/// </summary>
/// <returns></returns>
[HttpPost]
[Log(Title = "质量BackEnd扫码标签记录", BusinessType = BusinessType.INSERT)]
public IActionResult AddQcBackEndRecordLabelScan([FromBody] QcBackEndRecordLabelScanDto parm)
{
var modal = parm.Adapt<QcBackEndRecordLabelScan>().ToCreate(HttpContext);
var response = _QcBackEndRecordLabelScanService.AddQcBackEndRecordLabelScan(modal);
return SUCCESS(response);
}
/// <summary>
/// 更新质量BackEnd扫码标签记录
/// </summary>
/// <returns></returns>
[HttpPut]
[Log(Title = "质量BackEnd扫码标签记录", BusinessType = BusinessType.UPDATE)]
public IActionResult UpdateQcBackEndRecordLabelScan([FromBody] QcBackEndRecordLabelScanDto parm)
{
var modal = parm.Adapt<QcBackEndRecordLabelScan>().ToUpdate(HttpContext);
var response = _QcBackEndRecordLabelScanService.UpdateQcBackEndRecordLabelScan(modal);
return ToResponse(response);
}
/// <summary>
/// 删除质量BackEnd扫码标签记录
/// </summary>
/// <returns></returns>
[HttpDelete("{ids}")]
[Log(Title = "质量BackEnd扫码标签记录", BusinessType = BusinessType.DELETE)]
public IActionResult DeleteQcBackEndRecordLabelScan(string ids)
{
int[] idsArr = Tools.SpitIntArrary(ids);
if (idsArr.Length <= 0) { return ToResponse(ApiResult.Error($"删除失败Id 不能为空")); }
var response = _QcBackEndRecordLabelScanService.Delete(idsArr);
return ToResponse(response);
}
}
}

100
ZR.Admin.WebApi/Controllers/mes/qc/backend/QcBackEndRecordWorkorderDefectController.cs Normal file
View File

@@ -0,0 +1,100 @@
using Microsoft.AspNetCore.Mvc;
using ZR.Model.Dto;
using ZR.Model.Business;
using ZR.Service.Business.IBusinessService;
using ZR.Admin.WebApi.Extensions;
using ZR.Admin.WebApi.Filters;
//创建时间：2025-01-02
namespace ZR.Admin.WebApi.Controllers
{
/// <summary>
/// 质量BackEnd工单缺陷项记录
/// </summary>
[Verify]
[Route("/mes/qc/BackEnd/QcBackEndRecordWorkorderDefect")]
public class QcBackEndRecordWorkorderDefectController : BaseController
{
/// <summary>
/// 质量BackEnd工单缺陷项记录接口
/// </summary>
private readonly IQcBackEndRecordWorkorderDefectService _QcBackEndRecordWorkorderDefectService;
public QcBackEndRecordWorkorderDefectController(IQcBackEndRecordWorkorderDefectService QcBackEndRecordWorkorderDefectService)
{
_QcBackEndRecordWorkorderDefectService = QcBackEndRecordWorkorderDefectService;
}
/// <summary>
/// 查询质量BackEnd工单缺陷项记录列表
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
[HttpGet("list")]
public IActionResult QueryQcBackEndRecordWorkorderDefect([FromQuery] QcBackEndRecordWorkorderDefectQueryDto parm)
{
var response = _QcBackEndRecordWorkorderDefectService.GetList(parm);
return SUCCESS(response);
}
/// <summary>
/// 查询质量BackEnd工单缺陷项记录详情
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
[HttpGet("{Id}")]
public IActionResult GetQcBackEndRecordWorkorderDefect(string Id)
{
var response = _QcBackEndRecordWorkorderDefectService.GetInfo(Id);
var info = response.Adapt<QcBackEndRecordWorkorderDefect>();
return SUCCESS(info);
}
/// <summary>
/// 添加质量BackEnd工单缺陷项记录
/// </summary>
/// <returns></returns>
[HttpPost]
[Log(Title = "质量BackEnd工单缺陷项记录", BusinessType = BusinessType.INSERT)]
public IActionResult AddQcBackEndRecordWorkorderDefect([FromBody] QcBackEndRecordWorkorderDefectDto parm)
{
var modal = parm.Adapt<QcBackEndRecordWorkorderDefect>().ToCreate(HttpContext);
var response = _QcBackEndRecordWorkorderDefectService.AddQcBackEndRecordWorkorderDefect(modal);
return SUCCESS(response);
}
/// <summary>
/// 更新质量BackEnd工单缺陷项记录
/// </summary>
/// <returns></returns>
[HttpPut]
[Log(Title = "质量BackEnd工单缺陷项记录", BusinessType = BusinessType.UPDATE)]
public IActionResult UpdateQcBackEndRecordWorkorderDefect([FromBody] QcBackEndRecordWorkorderDefectDto parm)
{
var modal = parm.Adapt<QcBackEndRecordWorkorderDefect>().ToUpdate(HttpContext);
var response = _QcBackEndRecordWorkorderDefectService.UpdateQcBackEndRecordWorkorderDefect(modal);
return ToResponse(response);
}
/// <summary>
/// 删除质量BackEnd工单缺陷项记录
/// </summary>
/// <returns></returns>
[HttpDelete("{ids}")]
[Log(Title = "质量BackEnd工单缺陷项记录", BusinessType = BusinessType.DELETE)]
public IActionResult DeleteQcBackEndRecordWorkorderDefect(string ids)
{
int[] idsArr = Tools.SpitIntArrary(ids);
if (idsArr.Length <= 0) { return ToResponse(ApiResult.Error($"删除失败Id 不能为空")); }
var response = _QcBackEndRecordWorkorderDefectService.Delete(idsArr);
return ToResponse(response);
}
}
}

194
ZR.Admin.WebApi/Controllers/mes/qc/backend/QcBackEndServiceStatisticsController.cs Normal file
View File

@@ -0,0 +1,194 @@
using Microsoft.AspNetCore.Mvc;
using ZR.Admin.WebApi.Extensions;
using ZR.Admin.WebApi.Filters;
using ZR.Model.Business;
using ZR.Model.Dto;
using ZR.Service.Business.IBusinessService;
//创建时间：2025-01-02
namespace ZR.Admin.WebApi.Controllers
{
/// <summary>
/// 质量BackEnd统计报表业务模块
/// </summary>
[Verify]
[Route("/mes/qc/BackEnd/QcBackEndServiceStatistics")]
public class QcBackEndServiceStatisticsController : BaseController
{
/// <summary>
/// 质量BackEnd统计报表业务模块接口
/// </summary>
private readonly IQcBackEndServiceStatisticsService _QcBackEndServiceStatisticsService;
public QcBackEndServiceStatisticsController(
IQcBackEndServiceStatisticsService QcBackEndServiceStatisticsService
)
{
_QcBackEndServiceStatisticsService = QcBackEndServiceStatisticsService;
}
/// <summary>
/// 查询质量BackEnd统计报表业务模块列表
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
[HttpGet("list")]
public IActionResult QueryQcBackEndServiceStatistics(
[FromQuery] QcBackEndServiceStatisticsQueryDto parm
)
{
var response = _QcBackEndServiceStatisticsService.GetList(parm);
return SUCCESS(response);
}
/// <summary>
/// 查询质量BackEnd统计报表业务模块列表
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
[HttpPost("GetReviseList")]
[AllowAnonymous]
public IActionResult GetReviseList([FromBody] QcBackEndServiceStatisticsQueryDto parm)
{
var response = _QcBackEndServiceStatisticsService.GetReviseList(parm);
// 初始化统计数据
int totalRequireNumber = 0;
int totalQualifiedNumber = 0;
int totalPolishNumber = 0;
int totalDamoNumber = 0;
int totalBaofeiNumber = 0;
int totalListCount = 0;
// 将动态属性转换为字典并合并到主对象中，并计算统计数据
var resultWithDefects = response
.Select(item =>
{
var itemDict = new Dictionary<string, object>();
foreach (var prop in typeof(QcBackEndServiceStatisticsDto).GetProperties())
{
itemDict[prop.Name] = prop.GetValue(item);
}
// 添加动态属性
foreach (var dynamicProp in item.DynamicProperties)
{
itemDict[dynamicProp.Key] = dynamicProp.Value;
}
// 累加统计数据
totalRequireNumber += Convert.ToInt32(item.RequireNumber);
totalQualifiedNumber += Convert.ToInt32(item.QualifiedNumber);
totalPolishNumber += Convert.ToInt32(item.PolishNumber);
totalDamoNumber += Convert.ToInt32(item.DamoNumber);
totalBaofeiNumber += Convert.ToInt32(item.BaofeiNumber);
totalListCount += 1;
// 移除不要的属性
itemDict["DynamicProperties"] = null;
itemDict["GroupDefectJson"] = "";
return itemDict;
})
.ToList();
// 数据除三
totalRequireNumber = totalRequireNumber / 3;
totalQualifiedNumber = totalQualifiedNumber / 3;
totalPolishNumber = totalPolishNumber / 3;
totalDamoNumber = totalDamoNumber / 3;
totalBaofeiNumber = totalBaofeiNumber / 3;
totalListCount = totalListCount / 3;
// 计算合格率
double qualifiedRate = 0.0;
if (totalRequireNumber > 0)
{
qualifiedRate = (double)totalQualifiedNumber / totalRequireNumber * 100;
}
else
{
qualifiedRate = 0.0;
}
// 创建统计数据字典
var statistics = new Dictionary<string, object>
{
{ "TotalRequireNumber", totalRequireNumber },
{ "TotalQualifiedNumber", totalQualifiedNumber },
{ "QualifiedRate", $"{qualifiedRate:F1}%" },
{ "TotalPolishNumber", totalPolishNumber },
{ "TotalDamoNumber", totalDamoNumber },
{ "TotalBaofeiNumber", totalBaofeiNumber },
{ "TotalListCount", totalListCount }
};
// 创建分页结果
var pageList = resultWithDefects.Skip((parm.PageNum - 1) * parm.PageSize).Take(parm.PageSize).ToList();
// 返回包含数据和统计数据的对象
var result = new { statistics = statistics, pageList ,total = resultWithDefects.Count };
return SUCCESS(result);
}
/// <summary>
/// 查询质量BackEnd统计报表业务模块详情
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
[HttpGet("{Id}")]
public IActionResult GetQcBackEndServiceStatistics(string Id)
{
var response = _QcBackEndServiceStatisticsService.GetInfo(Id);
var info = response.Adapt<QcBackEndServiceStatistics>();
return SUCCESS(info);
}
/// <summary>
/// 添加质量BackEnd统计报表业务模块
/// </summary>
/// <returns></returns>
[HttpPost]
[Log(Title = "质量BackEnd统计报表业务模块", BusinessType = BusinessType.INSERT)]
public IActionResult AddQcBackEndServiceStatistics([FromBody] QcBackEndServiceStatisticsDto parm)
{
var modal = parm.Adapt<QcBackEndServiceStatistics>().ToCreate(HttpContext);
var response = _QcBackEndServiceStatisticsService.AddQcBackEndServiceStatistics(modal);
return SUCCESS(response);
}
/// <summary>
/// 更新质量BackEnd统计报表业务模块
/// </summary>
/// <returns></returns>
[HttpPut]
[Log(Title = "质量BackEnd统计报表业务模块", BusinessType = BusinessType.UPDATE)]
public IActionResult UpdateQcBackEndServiceStatistics(
[FromBody] QcBackEndServiceStatisticsDto parm
)
{
var modal = parm.Adapt<QcBackEndServiceStatistics>().ToUpdate(HttpContext);
var response = _QcBackEndServiceStatisticsService.UpdateQcBackEndServiceStatistics(modal);
return ToResponse(response);
}
/// <summary>
/// 删除质量BackEnd统计报表业务模块
/// </summary>
/// <returns></returns>
[HttpDelete("{ids}")]
[Log(Title = "质量BackEnd统计报表业务模块", BusinessType = BusinessType.DELETE)]
public IActionResult DeleteQcBackEndServiceStatistics(string ids)
{
int[] idsArr = Tools.SpitIntArrary(ids);
if (idsArr.Length <= 0)
{
return ToResponse(ApiResult.Error($"删除失败Id 不能为空"));
}
var response = _QcBackEndServiceStatisticsService.Delete(idsArr);
return ToResponse(response);
}
}
}

104
ZR.Admin.WebApi/Controllers/mes/qc/backend/QcBackEndServiceWorkorderController.cs Normal file
View File

@@ -0,0 +1,104 @@
using Microsoft.AspNetCore.Mvc;
using ZR.Model.Dto;
using ZR.Model.Business;
using ZR.Service.Business.IBusinessService;
using ZR.Admin.WebApi.Extensions;
using ZR.Admin.WebApi.Filters;
//创建时间：2025-01-02
namespace ZR.Admin.WebApi.Controllers
{
/// <summary>
/// 质量BackEnd工单业务模块
/// </summary>
[Verify]
[Route("/mes/qc/BackEnd/QcBackEndServiceWorkorder")]
public class QcBackEndServiceWorkorderController : BaseController
{
/// <summary>
/// 质量BackEnd工单业务模块接口
/// </summary>
private readonly IQcBackEndServiceWorkorderService _QcBackEndServiceWorkorderService;
public QcBackEndServiceWorkorderController(IQcBackEndServiceWorkorderService QcBackEndServiceWorkorderService)
{
_QcBackEndServiceWorkorderService = QcBackEndServiceWorkorderService;
}
/// <summary>
/// 查询质量BackEnd工单业务模块列表
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
[HttpGet("list")]
public IActionResult QueryQcBackEndServiceWorkorder([FromQuery] QcBackEndServiceWorkorderQueryDto parm)
{
var response = _QcBackEndServiceWorkorderService.GetList(parm);
return SUCCESS(response);
}
/// <summary>
/// 查询质量BackEnd工单业务模块详情
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
[HttpGet("{Id}")]
public IActionResult GetQcBackEndServiceWorkorder(string Id)
{
var response = _QcBackEndServiceWorkorderService.GetInfo(Id);
var info = response.Adapt<QcBackEndServiceWorkorder>();
return SUCCESS(info);
}
/// <summary>
/// 添加质量BackEnd工单业务模块
/// </summary>
/// <returns></returns>
[HttpPost]
[Log(Title = "质量BackEnd工单业务模块", BusinessType = BusinessType.INSERT)]
public IActionResult AddQcBackEndServiceWorkorder([FromBody] QcBackEndServiceWorkorderDto parm)
{
var modal = parm.Adapt<QcBackEndServiceWorkorder>().ToCreate(HttpContext);
var response = _QcBackEndServiceWorkorderService.AddQcBackEndServiceWorkorder(modal);
return SUCCESS(response);
}
/// <summary>
/// 更新质量BackEnd工单业务模块
/// </summary>
/// <returns></returns>
[HttpPut]
[Log(Title = "质量BackEnd工单业务模块", BusinessType = BusinessType.UPDATE)]
public IActionResult UpdateQcBackEndServiceWorkorder([FromBody] QcBackEndServiceWorkorderDto parm)
{
var modal = parm.Adapt<QcBackEndServiceWorkorder>().ToUpdate(HttpContext);
var response = _QcBackEndServiceWorkorderService.UpdateQcBackEndServiceWorkorder(modal);
return ToResponse(response);
}
/// <summary>
/// 删除质量BackEnd工单业务模块
/// </summary>
/// <returns></returns>
[HttpDelete("{ids}")]
[Log(Title = "质量BackEnd工单业务模块", BusinessType = BusinessType.DELETE)]
public IActionResult DeleteQcBackEndServiceWorkorder(string ids)
{
int[] idsArr = Tools.SpitIntArrary(ids);
if (idsArr.Length <= 0) { return ToResponse(ApiResult.Error($"删除失败Id 不能为空")); }
var response = _QcBackEndServiceWorkorderService.Delete(idsArr);
return ToResponse(response);
}
}
}

111
ZR.Admin.WebApi/Controllers/mes/qc/backend/QcBackendBaseOutpackageController.cs Normal file
View File

@@ -0,0 +1,111 @@
using Microsoft.AspNetCore.Mvc;
using ZR.Admin.WebApi.Extensions;
using ZR.Admin.WebApi.Filters;
using ZR.Model.Business;
using ZR.Model.Dto;
using ZR.Service.Business.IBusinessService;
//创建时间：2025-05-06
namespace ZR.Admin.WebApi.Controllers
{
/// <summary>
/// 质量后道外箱标签打印配置
/// </summary>
[Verify]
[Route("/mes/qc/BackEnd/QcBackendBaseOutpackage")]
public class QcBackendBaseOutpackageController : BaseController
{
/// <summary>
/// 质量后道外箱标签打印配置
/// </summary>
private readonly IQcBackendBaseOutpackageService _QcBackendBaseOutpackageService;
public QcBackendBaseOutpackageController(
IQcBackendBaseOutpackageService QcBackendBaseOutpackageService
)
{
_QcBackendBaseOutpackageService = QcBackendBaseOutpackageService;
}
/// <summary>
/// 查询质量后道外箱标签打印配置
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
[HttpGet("list")]
[ActionPermissionFilter(Permission = "business:qcbackendbaseoutpackage:list")]
public IActionResult QueryQcBackendBaseOutpackage(
[FromQuery] QcBackendBaseOutpackageQueryDto parm
)
{
var response = _QcBackendBaseOutpackageService.GetList(parm);
return SUCCESS(response);
}
/// <summary>
/// 查询质量后道外箱标签打印配置
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
[HttpGet("{Id}")]
[ActionPermissionFilter(Permission = "business:qcbackendbaseoutpackage:query")]
public IActionResult GetQcBackendBaseOutpackage(int Id)
{
var response = _QcBackendBaseOutpackageService.GetInfo(Id);
var info = response.Adapt<QcBackendBaseOutpackage>();
return SUCCESS(info);
}
/// <summary>
/// 添加质量后道外箱标签打印配置
/// </summary>
/// <returns></returns>
[HttpPost]
public IActionResult AddQcBackendBaseOutpackage([FromBody] QcBackendBaseOutpackageDto parm)
{
var modal = parm.Adapt<QcBackendBaseOutpackage>().ToCreate(HttpContext);
var response = _QcBackendBaseOutpackageService.AddQcBackendBaseOutpackage(modal);
return SUCCESS(response);
}
/// <summary>
/// 更新质量后道外箱标签打印配置
/// </summary>
/// <returns></returns>
[HttpPut]
public IActionResult UpdateQcBackendBaseOutpackage(
[FromBody] QcBackendBaseOutpackageDto parm
)
{
var modal = parm.Adapt<QcBackendBaseOutpackage>().ToUpdate(HttpContext);
var response = _QcBackendBaseOutpackageService.UpdateQcBackendBaseOutpackage(modal);
return ToResponse(response);
}
/// <summary>
/// 删除质量后道外箱标签打印配置
/// </summary>
/// <returns></returns>
[HttpDelete("{ids}")]
public IActionResult DeleteQcBackendBaseOutpackage(string ids)
{
int[] idsArr = Tools.SpitIntArrary(ids);
if (idsArr.Length <= 0)
{
return ToResponse(ApiResult.Error($"删除失败Id 不能为空"));
}
var response = _QcBackendBaseOutpackageService.Delete(idsArr);
return ToResponse(response);
}
}
}