zszq-trs/YLErpDAL/Modules/ClientModule/ClientInvestorService.cs

using BaseOUDAL;
using System.Data;
using YieldChain.Helpers;
using YLErp.Commons;
using YLErp.Helpers;
using YLErp.Model.Enum;

namespace YLErp.Modules.ClientModule
{
    /// <summary>
    /// 客户产品投资人服务
    /// </summary>
    public partial class ClientInvestorService : ClientBaseService
    {
        public ClientInvestorService(OptUserInfo userInfo) : base(userInfo)
        {

        }

        /// <summary>
        /// 查询ClientInvestor
        /// </summary>
        public SearchListResult<ClientInvestor> SearchList(ClientInvestorReq req)
        {
            var query = DbContext.ClientInvestor.AsNoTracking().AsQueryable();

            if (!string.IsNullOrEmpty(req.Investor))
            {
                query = query.Where(d => d.Investor.Contains(req.Investor));
            }

            if (!string.IsNullOrEmpty(req.EligibilityType))
            {
                query = query.Where(d => d.EligibilityType.Contains(req.EligibilityType));
            }

            if (req.ClientId != null)
            {
                query = query.Where(d => d.ClientId == req.ClientId);
            }

            if (!string.IsNullOrEmpty(req.ClientName))
            {
                query = query.Where(d => d.ClientName.Contains(req.ClientName));
            }

            if (req.OptId != null)
            {
                query = query.Where(d => d.OptId == req.OptId);
            }

            if (!string.IsNullOrEmpty(req.OptName))
            {
                query = query.Where(d => d.OptName.Contains(req.OptName));
            }

            if (req.OptDateStart != DateTime.MinValue)
            {
                query = query.Where(d => d.OptDate >= req.OptDateStart);
            }

            if (req.OptDateEnd != DateTime.MinValue)
            {
                var OptDateTemp = req.OptDateEnd.AddDays(1);
                query = query.Where(d => d.OptDate < OptDateTemp);
            }

            if (string.IsNullOrEmpty(req.sidx))
            {
                req.sidx = "id";
                req.sord = "desc";
            }
            var retListResult = query.ToSearchList(req);

            return retListResult;
        }

        /// <summary>
        /// 保存产品投资人数据
        /// </summary>
        public ClientInvestor SaveInvestor(HashSet<string> updatedPropertyNameSet, ClientInvestor req, out Client client)
        {
            return InnerSaveInvestor(updatedPropertyNameSet, req, out client, false);
        }

        private ClientInvestor InnerSaveInvestor(HashSet<string> updatedPropertyNameSet, ClientInvestor req, out Client client, bool doInvalid)
        {
            ClientInvestor dbmodel;

            var changeStr = string.Empty;

            client = req.ClientId > 0 ? DbContext.client.Find(req.ClientId) : null;

            if (client == null)
            {
                throw new ServiceException("没有找到客户数据");
            }

            checkInvestor(req, client);

            //新增
            if (req.id < 1)
            {
                DbContext.ClientInvestor.Add(dbmodel = new ClientInvestor());

                DbContext.ClientAuditLog.Add(new ClientAuditLog
                {
                    ClientId = req.ClientId ?? 0,
                    OptType = "新建产品投资人",
                    Changes = string.Empty,
                    DataType = "00",
                    OptId = UserId,
                    OptName = UserName,
                    OptDate = OptDate
                });
            }
            else
            {
                dbmodel = DbContext.ClientInvestor.Find(req.id);

                if (dbmodel == null)
                {
                    throw new ServiceException("未找到对应的产品投资人信息,请刷新后再试!");
                }

                if (doInvalid && req.ValidState == dbmodel.ValidState)
                {
                    return dbmodel;
                }

                changeStr = DataChangeHelper.GetDataChanges(dbmodel, req).ToJson();
            }

            ObjectHelper.MapValues(dbmodel, req, updatedPropertyNameSet);

            SetDBModelOpt(dbmodel);

            if (req.id > 0)
            {
                DbContext.ClientAuditLog.Add(new ClientAuditLog
                {
                    ClientId = dbmodel.ClientId ?? 0,
                    OptType = "编辑产品投资人",
                    Changes = changeStr,
                    DataType = "C02",
                    OptId = UserId,
                    OptName = UserName,
                    OptDate = OptDate
                });
            }
            DbContext.SaveChanges();

            return dbmodel;
        }

        /// <summary>
        /// 投资人检查
        /// </summary>
        /// <param name="req"></param>
        /// <param name="client"></param>
        /// <returns></returns>
        private bool checkInvestor(ClientInvestor req, Client client)
        {
            //产品用户投资者，如果存在收益互换权限 只有专业投资者权益百分比可以大于20%
            if (client.ClientType == ClientTypeEnum.产品.ToString() && client.DerivativesInvestmentVarieties.Contains((int)DerivativesInvestmentVarietiesEnum.场外互换 + "")
                && !"专业投资者".Equals(req.EligibilityType) && req.ShareRate > 0.2)
            {
                throw new ServiceException("本产品客户，存在非专业投资人权益比例大于20%情况，无法进行场外互换交易！");
            }
            return true;
        }

        /// <summary>
        /// 导出产品投资人数据到EXCEL文件
        /// </summary>
        public byte[] ExportInvestorsToExcel(IEnumerable<int> clientIds)
        {
            var ret = DbContext.ClientInvestor.AsNoTracking().AsQueryable().Where(o => clientIds.Contains(o.ClientId ?? 0)).OrderBy(o => o.ClientName).ToList();

            var dc = new List<ExcelHelper.DataColumnModel>
            {
                new ExcelHelper.DataColumnModel("客户名称", "ClientId", (cv, obj) =>
                {
                    var id = (int?)cv ?? 0;
                    return DbContext.client.Where(o => o.id == id).FirstOrDefault().Name;
                }),
                new ExcelHelper.DataColumnModel("投资人", "Investor"),
                new ExcelHelper.DataColumnModel("适当性类型", "EligibilityType"),
                new ExcelHelper.DataColumnModel("权益占比", "ShareRate"),
                new ExcelHelper.DataColumnModel("是否有效", "ValidState", (cv, obj) =>
                 {
                     if (cv == "InValid")
                     {
                         return "无效";
                     }
                     return "有效";
                 }),
                new ExcelHelper.DataColumnModel("客户备注", "Comments")
            };
            new ExcelHelper().ListToExcel<ClientInvestor>(dc.ToArray(), ret, "客户产品投资人信息", true, out var buffer);
            return buffer;
        }
    }

    /// <summary>
    /// 客户产品投资人查询请求
    /// </summary>
    public class ClientInvestorReq : BaseSearchReq
    {
        /// <summary>
        /// 投资人
        /// </summary> 
        public string Investor { get; set; }

        /// <summary>
        /// 适当性类型
        /// </summary> 
        public string EligibilityType { get; set; }

        /// <summary>
        /// 权益占比
        /// </summary> 
        public string ShareRate { get; set; }

        /// <summary>
        /// 客户信息
        /// </summary> 
        public int? ClientId { get; set; }


        /// <summary>
        /// 客户名称
        /// </summary> 
        public string ClientName { get; set; }


        /// <summary>
        /// 操作者_optid
        /// </summary> 
        public int? OptId { get; set; }


        /// <summary>
        /// 操作者_optname
        /// </summary> 
        public string OptName { get; set; }


        /// <summary>
        /// 操作日期_createdate
        /// </summary> 
        public DateTime? OptDate { get; set; }

        public DateTime OptDateStart { get; set; }

        public DateTime OptDateEnd { get; set; }

        public string Comments { get; set; }
    }
}