zszq-trs/YLErpWeb/Controllers/RiskRuleController.cs

using Qdp.Foundation.Utilities;
using YLErp.DBModels;
using YLErp.Modules.RiskEngine;
using YLErp.Modules.RiskEngine.Dto;

namespace YLErp.Web.Controllers
{
    /// <summary>风控引擎管理控制器，提供规则、应用配置、变量池和审计日志的 CRUD 接口</summary>
    [Route("risk-engine")]
    public class RiskRuleController : BaseController
    {
        private readonly IYcLogger _logger = LogFactory.GetLogger("RiskRuleController");

        #region Rule Management

        [HttpGet("risk-rules")]
        [MyAuthorize("风险控制-风控规则查看")]
        /// <summary>查询风控规则列表（分页）</summary>
        public JsonResult QueryRiskRules(QueryRiskRuleReq req)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.QueryRuleList(req);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询风控规则列表");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpGet("risk-rules/{id}")]
        [MyAuthorize("风险控制-风控规则查看")]
        /// <summary>获取风控规则详情</summary>
        public JsonResult GetRiskRule(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.GetRuleDetail(id);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询风控规则详情");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpGet("risk-rules/{id}/versions")]
        [MyAuthorize("风险控制-风控规则查看")]
        /// <summary>获取风控规则版本历史</summary>
        public JsonResult GetRiskRuleVersions(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.GetRuleVersions(id);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询风控规则版本历史");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpPost("risk-rules")]
        [MyAuthorize("风险控制-风控规则新增")]
        /// <summary>创建风控规则</summary>
        public JsonResult CreateRiskRule([FromBody] CreateRiskRuleReq req)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.CreateRule(req);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "创建风控规则");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpPut("risk-rules/{id}")]
        [MyAuthorize("风险控制-风控规则编辑")]
        /// <summary>更新风控规则</summary>
        public JsonResult UpdateRiskRule(long id, [FromBody] UpdateRiskRuleReq req)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.UpdateRule(id, req);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "更新风控规则");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpDelete("risk-rules/{id}")]
        [MyAuthorize("风险控制-风控规则删除")]
        /// <summary>删除风控规则（软删除）</summary>
        public JsonResult DeleteRiskRule(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                service.DeleteRule(id);
                return Json(new { success = true });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "删除风控规则");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpDelete("risk-rules/batch")]
        [MyAuthorize("风险控制-风控规则删除")]
        /// <summary>批量删除风控规则</summary>
        public JsonResult BatchDeleteRiskRules([FromBody] List<long> ids)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.BatchDeleteRules(ids);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "批量删除风控规则");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpPost("risk-rules/{id}/enable")]
        [MyAuthorize("风险控制-风控规则启停")]
        /// <summary>启用风控规则</summary>
        public JsonResult EnableRiskRule(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                service.EnableRule(id);
                return Json(new { success = true });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "启用风控规则");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpPost("risk-rules/{id}/disable")]
        [MyAuthorize("风险控制-风控规则启停")]
        /// <summary>停用风控规则</summary>
        public JsonResult DisableRiskRule(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                service.DisableRule(id);
                return Json(new { success = true });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "停用风控规则");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpGet("risk-rules/{id}/applications")]
        [MyAuthorize("风险控制-风控规则查看")]
        /// <summary>获取规则关联的应用配置列表</summary>
        public JsonResult GetRuleApplications(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.GetRuleApplications(id);
                return Json(new { success = true, data = new { rows = result, total = result.Count, records = result.Count, page = 1 } });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询规则关联应用列表");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpGet("risk-rules/list")]
        [MyAuthorize("风险控制-风控规则查看")]
        /// <summary>获取所有启用规则列表（供下拉选择）</summary>
        public JsonResult GetAllRiskRules()
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.GetAllRuleList();
                return Json(new { success = true, data = new { rows = result, total = result.Count, records = result.Count, page = 1 } });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询规则下拉列表");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        #endregion

        #region Application Management

        [HttpGet("risk-applications")]
        [MyAuthorize("风险控制-风控应用查看")]
        /// <summary>查询应用配置列表（分页）</summary>
        public JsonResult QueryRiskApplications(QueryRiskApplicationReq req)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.QueryApplicationList(req);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询应用配置列表");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpGet("risk-applications/{id}")]
        [MyAuthorize("风险控制-风控应用查看")]
        /// <summary>获取应用配置详情</summary>
        public JsonResult GetRiskApplication(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.GetApplicationDetail(id);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询应用配置详情");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpPost("risk-applications")]
        [MyAuthorize("风险控制-风控应用新增")]
        /// <summary>创建应用配置</summary>
        public JsonResult CreateRiskApplication([FromBody] CreateRiskApplicationReq req)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.CreateApplication(req);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "创建应用配置");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpPut("risk-applications/{id}")]
        [MyAuthorize("风险控制-风控应用编辑")]
        /// <summary>更新应用配置</summary>
        public JsonResult UpdateRiskApplication(long id, [FromBody] UpdateRiskApplicationReq req)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.UpdateApplication(id, req);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "更新应用配置");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpDelete("risk-applications/{id}")]
        [MyAuthorize("风险控制-风控应用删除")]
        /// <summary>删除应用配置（软删除）</summary>
        public JsonResult DeleteRiskApplication(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                service.DeleteApplication(id);
                return Json(new { success = true });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "删除应用配置");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpPost("risk-applications/{id}/enable")]
        [MyAuthorize("风险控制-风控应用启停")]
        /// <summary>启用应用配置</summary>
        public JsonResult EnableRiskApplication(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                service.EnableApplication(id);
                return Json(new { success = true });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "启用应用配置");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpPost("risk-applications/{id}/disable")]
        [MyAuthorize("风险控制-风控应用启停")]
        /// <summary>停用应用配置</summary>
        public JsonResult DisableRiskApplication(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                service.DisableApplication(id);
                return Json(new { success = true });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "停用应用配置");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpPost("risk-applications/batch-enable")]
        [MyAuthorize("风险控制-风控应用启停")]
        /// <summary>批量启用应用配置</summary>
        public JsonResult BatchEnableRiskApplications([FromBody] List<long> ids)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.BatchEnableApplications(ids);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "批量启用应用配置");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpPost("risk-applications/batch-disable")]
        [MyAuthorize("风险控制-风控应用启停")]
        /// <summary>批量停用应用配置</summary>
        public JsonResult BatchDisableRiskApplications([FromBody] List<long> ids)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.BatchDisableApplications(ids);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "批量停用应用配置");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        #endregion

        #region Variable Management

        [HttpGet("risk-variables")]
        [MyAuthorize("风险控制-风控变量查看")]
        /// <summary>查询变量列表</summary>
        public JsonResult QueryRiskVariables(QueryRiskVariableReq req)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.QueryVariableList(req);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询变量列表");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpGet("risk-variables/{id}")]
        [MyAuthorize("风险控制-风控变量查看")]
        /// <summary>获取变量详情</summary>
        public JsonResult GetRiskVariable(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.GetVariableDetail(id);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询变量详情");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpGet("risk-variables/list")]
        [MyAuthorize("风险控制-风控变量查看")]
        /// <summary>获取所有变量列表（供下拉选择）</summary>
        public JsonResult GetAllRiskVariables()
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.GetAllVariableList();
                return Json(new { success = true, data = new { rows = result, total = result.Count, records = result.Count, page = 1 } });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询全部变量列表");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpPost("risk-variables")]
        [MyAuthorize("风险控制-风控变量新增")]
        /// <summary>创建变量</summary>
        public JsonResult CreateRiskVariable([FromBody] CreateRiskVariableReq req)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.CreateVariable(req);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "创建变量");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpPut("risk-variables/{id}")]
        [MyAuthorize("风险控制-风控变量编辑")]
        /// <summary>更新变量（含级联更新引用规则的 RuleExpr）</summary>
        public JsonResult UpdateRiskVariable(long id, [FromBody] UpdateRiskVariableReq req)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.UpdateVariable(id, req);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "更新变量");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpDelete("risk-variables/{id}")]
        [MyAuthorize("风险控制-风控变量删除")]
        /// <summary>删除变量</summary>
        public JsonResult DeleteRiskVariable(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                service.DeleteVariable(id);
                return Json(new { success = true });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "删除变量");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        #endregion

        #region Cache Management

        [HttpGet("riskCache/refresh")]
        [MyAuthorize("风险控制-异常交易监控")]
        /// <summary>手动刷新风控引擎缓存</summary>
        public JsonResult RefreshRiskEngineCache()
        {
            try
            {
                RiskEngineService.GetInstance().RefreshCache();
                return Json(new { success = true, message = "风控缓存刷新成功" });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "刷新风控缓存");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        #endregion

        #region Trade Types

        [HttpGet("trade-types")]
        [MyAuthorize("风险控制-风控应用查看")]
        /// <summary>获取合约类型列表</summary>
        public JsonResult GetTradeTypes()
        {
            try
            {
                var rows = ConsTrade.AllTradeTypes.Select(t => new { label = t, value = t }).ToList();
                var total = rows.Count;
                return Json(new {
                    success = true,
                    data = new {
                        page = 1,
                        records = total,
                        rows = rows,
                        total = total
                    }
                });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询合约类型列表");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        #endregion

        #region Audit Log

        [HttpGet("risk-audit-logs")]
        [MyAuthorize("风险控制-风控日志查看")]
        /// <summary>查询风控操作日志列表（分页）</summary>
        public JsonResult QueryRiskAuditLogs(QueryRiskAuditLogReq req)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.QueryAuditLogs(req);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询风控操作日志列表");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpGet("risk-audit-logs/{id}")]
        [MyAuthorize("风险控制-风控日志查看")]
        /// <summary>获取风控操作日志详情</summary>
        public JsonResult GetRiskAuditLogDetail(long id)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var result = service.GetAuditLogDetail(id);
                return Json(new { success = true, data = result });
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "查询风控操作日志详情");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        [HttpGet("risk-audit-logs/export")]
        [MyAuthorize("风险控制-风控日志导出")]
        /// <summary>导出风控操作日志为 Excel</summary>
        public IActionResult ExportRiskAuditLogs(QueryRiskAuditLogReq req)
        {
            try
            {
                var service = new RiskRuleService(CurUser);
                var bytes = service.ExportAuditLogs(req);
                return File(bytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "风控操作日志.xlsx");
            }
            catch (ServiceException ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "导出风控操作日志");
                return Json(new { success = false, message = "系统异常，请联系管理员" });
            }
        }

        #endregion
    }
}