LifePaymentApi.git

using AutoMapper.QueryableExtensions;
using LifePayment.Application.Contracts;
using LifePayment.Domain;
using LifePayment.Domain.LifePay;
using LifePayment.Domain.Models;
using LifePayment.Domain.Shared;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Nest;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Volo.Abp.Application.Services;
using Volo.Abp.AutoMapper;
using Volo.Abp.Domain.Repositories;
using ZeroD.Util;
 
namespace LifePayment.Application.Promoter
{
    /// <summary>
    /// 推广服务
    /// </summary>
    public class PromoterService : ApplicationService, IPromoterService
    {
        private readonly IMapperAccessor mapperAccessor;
        private readonly ILogger<PromoterService> logger;
        private readonly IRepository<LifePayPromoter, Guid> lifePayPromoterRepository;
        private readonly IRepository<LifePayChannelConsultation, Guid> lifePayChannelConsultationRepository;
        private readonly IRepository<LifePayChannelConsultationFollowup, Guid> lifePayChannelConsultationFollowupRepository;
        private readonly IRepository<User, Guid> userRepository;
 
        public PromoterService(
            IMapperAccessor mapperAccessor,
            ILogger<PromoterService> logger,
            IRepository<LifePayPromoter, Guid> lifePayPromoterRepository,
            IRepository<LifePayChannelConsultation, Guid> lifePayChannelConsultationRepository,
            IRepository<LifePayChannelConsultationFollowup, Guid> lifePayChannelConsultationFollowupRepository,
            IRepository<User, Guid> userRepository)
        {
            this.mapperAccessor = mapperAccessor;
            this.logger = logger;
            this.lifePayPromoterRepository = lifePayPromoterRepository;
            this.lifePayChannelConsultationRepository = lifePayChannelConsultationRepository;
            this.lifePayChannelConsultationFollowupRepository = lifePayChannelConsultationFollowupRepository;
            this.userRepository = userRepository;
        }
 
        #region 查询
 
        /// <summary>
        /// 获取推广员列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<PageOutput<PromoterDto>> GetPromoters(GetPromotersInput input)
        {
            var query = lifePayPromoterRepository.Select(it => new PromoterDto
            {
                Id = it.Id,
                CreationTime = it.CreationTime,
                IdNumber = it.IdNumber,
                Name = it.Name,
                PhoneNumber = it.PhoneNumber,
                ClickCount = it.ClickCount,
                ApplyCount = it.ApplyCount,
                Remark = it.Remark,
            });
            if (input.StartDate.HasValue)
            {
                query = query.Where(s => s.CreationTime >= input.StartDate);
            }
 
            if (input.EndDate.HasValue)
            {
                query = query.Where(s => s.CreationTime <= input.EndDate);
            }
 
            if (!string.IsNullOrEmpty(input.SearchKey))
            {
                query = query.Where(s =>
                    s.IdNumber.Contains(input.SearchKey)
                    || s.PhoneNumber.Contains(input.SearchKey)
                    || s.Name.Contains(input.SearchKey));
            }
 
            var result = await query.GetPageResult(input.PageModel);
            return result;
        }
 
        /// <summary>
        /// 获取渠道咨询列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<PageOutput<ChannelConsultationDto>> GetChannelConsultation(GetChannelConsultationsInput input)
        {
            var query = from cc in lifePayChannelConsultationRepository
                        join p in lifePayPromoterRepository on cc.PromoterId equals p.Id into pg
                        from pgd in pg.DefaultIfEmpty()
                        select new ChannelConsultationDto
                        {
                            Id = cc.Id,
                            CreationTime = cc.CreationTime,
                            Name = cc.Name,
                            AgentType = cc.AgentType,
                            PhoneNumber = cc.PhoneNumber,
                            CompanyName = cc.CompanyName,
                            CustomerResources = cc.CustomerResources,
                            PromoterIdNumber = pgd.IdNumber,
                            PromoterName = pgd.Name,
                            PromoterPhoneNumber = pgd.PhoneNumber,
                            FollowupStatus = cc.FollowupStatus,
                            LastFollowupTime = cc.LastFollowupTime,
                            FollowupRemark = cc.FollowupRemark,
                        };
            if (input.StartDate.HasValue)
            {
                query = query.Where(s => s.CreationTime >= input.StartDate);
            }
 
            if (input.EndDate.HasValue)
            {
                query = query.Where(s => s.CreationTime <= input.EndDate);
            }
 
            if (!string.IsNullOrEmpty(input.SearchKey))
            {
                query = query.Where(s =>
                    s.Name.Contains(input.SearchKey)
                    || s.PhoneNumber.Contains(input.SearchKey)
                    || s.Name.Contains(input.SearchKey)
                    || s.PhoneNumber.Contains(input.SearchKey));
            }
 
            var result = await query.GetPageResult(input.PageModel);
            return result;
        }
 
        /// <summary>
        /// 获取渠道咨询回访记录
        /// </summary>
        /// <param name="id">渠道咨询Id</param>
        /// <returns></returns>
        public async Task<List<ChannelConsultationFollowupDto>> GetChannelConsultationFollowupList(Guid id)
        {
            var query = from f in lifePayChannelConsultationFollowupRepository
                        join u in userRepository on f.CreatorId equals u.Id into ug
                        from ugd in ug.DefaultIfEmpty()
                        where f.ChannelConsultationId == id
                        select new ChannelConsultationFollowupDto
                        {
                            CreatorId = f.CreatorId,
                            Creator = ugd.Name,
                            FollowupStatus = f.FollowupStatus,
                            FollowupRemark = f.FollowupRemark,
                            CreationTime = f.CreationTime,
                        };
            var list = await query.ToListAsync();
            return list;
        }
 
        #endregion
 
        #region 写入
 
        /// <summary>
        /// 创建或更新推广员
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="FormatException"></exception>
        public async Task<Guid> CreateOrUpdatePromoter(CreateOrUpdatePromoterInput input)
        {
            CheckExtensions.IfTrueThrowUserFriendlyException(string.IsNullOrWhiteSpace(input.Name), "请输入推广人");
            CheckExtensions.IfTrueThrowUserFriendlyException(string.IsNullOrWhiteSpace(input.PhoneNumber), "请输入联系方式");
            if (string.IsNullOrEmpty(input.IdNumber))
            {
                input.IdNumber = BuildIdNumber();
            }
            else if (input.Id == null)
            {
                var exist = await lifePayPromoterRepository.FirstOrDefaultAsync(it => it.IdNumber == input.IdNumber || it.PhoneNumber == input.PhoneNumber);
                if (exist != null)
                {
                    if (exist.IdNumber == input.IdNumber)
                    {
                        throw new FormatException("该ID已存在");
                    }
 
                    if (exist.PhoneNumber == input.PhoneNumber)
                    {
                        throw new FormatException("该手机号已申请");
                    }
                }
            }
 
            if (input.Id == null)
            {
                var entity = new LifePayPromoter();
                ObjectMapper.Map(input, entity);
                await lifePayPromoterRepository.InsertAsync(entity);
                return entity.Id;
            }
            else
            {
                var entity = await lifePayPromoterRepository.FirstOrDefaultAsync(it => it.Id == input.Id);
                CheckExtensions.IfTrueThrowUserFriendlyException(entity == null, "该推广员不存在");
                ObjectMapper.Map(input, entity);
                await lifePayPromoterRepository.UpdateAsync(entity);
                return entity.Id;
            }
        }
 
        /// <summary>
        /// 点击数+1
        /// </summary>
        /// <param name="idnumber"></param>
        /// <returns></returns>
        public async Task SetClickCount(string idnumber)
        {
            var entity = await lifePayPromoterRepository.FirstOrDefaultAsync(it => it.IdNumber == idnumber);
            CheckExtensions.IfTrueThrowUserFriendlyException(entity == null, "该推广员不存在");
            entity.ClickCount++;
            await lifePayPromoterRepository.UpdateAsync(entity);
        }
 
        /// <summary>
        /// 申请渠道咨询
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<Guid> CreateChannelConsultation(CreateChannelConsultationInput input)
        {
            CheckExtensions.IfTrueThrowUserFriendlyException(string.IsNullOrWhiteSpace(input.Name), "请输入姓名");
            CheckExtensions.IfTrueThrowUserFriendlyException(string.IsNullOrWhiteSpace(input.PhoneNumber), "请输入联系方式");
            CheckExtensions.IfTrueThrowUserFriendlyException(input.AgentType == null, "请选择代理类型");
            CheckExtensions.IfTrueThrowUserFriendlyException(string.IsNullOrWhiteSpace(input.CustomerResources), "请输入客户资源");
 
            var entity = new LifePayChannelConsultation();
            ObjectMapper.Map(input, entity);
 
            if (!string.IsNullOrWhiteSpace(input.IdNumber))
            {
                var promoter = await lifePayPromoterRepository.FirstOrDefaultAsync(it => it.IdNumber == input.IdNumber);
                if (promoter != null)
                {
                    entity.PromoterId = promoter.Id;
                    promoter.ApplyCount++;
                    await lifePayPromoterRepository.UpdateAsync(promoter);
                }
            }
 
            await lifePayChannelConsultationRepository.InsertAsync(entity);
 
            return entity.Id;
        }
 
        /// <summary>
        /// 新增回访
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<Guid> CreateChannelConsultationFollowup(CreateChannelConsultationFollowupInput input)
        {
            CheckExtensions.IfTrueThrowUserFriendlyException(input.FollowupStatus == null, "请选择回访状态");
            CheckExtensions.IfTrueThrowUserFriendlyException(string.IsNullOrWhiteSpace(input.FollowupRemark), "请输入回访记录");
 
            var consultation = await lifePayChannelConsultationRepository.FirstOrDefaultAsync(it => it.Id == input.ChannelConsultationId);
            CheckExtensions.IfTrueThrowUserFriendlyException(consultation == null, "该渠道咨询不存在");
 
            var entity = new LifePayChannelConsultationFollowup();
            ObjectMapper.Map(input, entity);
            await lifePayChannelConsultationFollowupRepository.InsertAsync(entity);
 
            consultation.FollowupRemark = entity.FollowupRemark;
            consultation.FollowupStatus = entity.FollowupStatus;
            consultation.LastFollowupTime = entity.CreationTime;
            await lifePayChannelConsultationRepository.UpdateAsync(consultation);
 
            return entity.Id;
        }
 
        #endregion
 
        /// <summary>
        /// 生成Id
        /// </summary>
        /// <returns></returns>
        private string BuildIdNumber()
        {
            var num = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
            var exist = lifePayPromoterRepository.Any(it => it.IdNumber == num);
            if (exist)
            {
                return BuildIdNumber();
            }
 
            return num;
        }
 
    }
}