using AutoMapper.QueryableExtensions;
|
using LifePayment.Application.Contracts;
|
using LifePayment.Application.Contracts.LifePay;
|
using LifePayment.Domain;
|
using LifePayment.Domain.LifePay;
|
using LifePayment.Domain.Models;
|
using LifePayment.Domain.Shared;
|
using Microsoft.EntityFrameworkCore;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
using System.Threading.Tasks;
|
using Volo.Abp.Application.Services;
|
using Volo.Abp.Domain.Repositories;
|
using Volo.Abp.ObjectMapping;
|
using ZeroD.Util;
|
using ZeroD.Util.Fadd;
|
|
namespace LifePayment.Application.LifePay;
|
|
|
public class LifePayAnnouncementService : ApplicationService, ILifePayAnnouncementService
|
{
|
private readonly IRepository<LifePayAnnouncement, Guid> _lifePayAnnouncementRepository;
|
|
public LifePayAnnouncementService(IRepository<LifePayAnnouncement, Guid> lifePayAnnouncementRepository)
|
{
|
_lifePayAnnouncementRepository = lifePayAnnouncementRepository;
|
}
|
|
/// <summary>
|
/// 获取公告分页
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
public async Task<PageOutput<CreateEditLifePayAnnouncementOutput>> GetLifePayAnnouncementPage(GetLifePayAnnouncementPageInput input)
|
{
|
var currentTime = DateTime.Now;
|
var query = _lifePayAnnouncementRepository
|
.WhereIf(input.CreationTimeBegin.HasValue, x => x.CreationTime >= input.CreationTimeBegin)
|
.WhereIf(input.CreationTimeEnd.HasValue, x => x.CreationTime <= input.CreationTimeEnd)
|
.WhereIf(input.StartTime.HasValue, x => x.StartTime >= input.StartTime)
|
.WhereIf(input.EndTime.HasValue, x => x.EndTime <= input.EndTime)
|
.WhereIf(input.Status.HasValue, x => input.Status.Value == AnnouncementStatusEnum.Wait
|
? currentTime < x.StartTime
|
: input.Status.Value == AnnouncementStatusEnum.Showing
|
? currentTime >= x.StartTime && currentTime <= x.EndTime
|
: input.Status.Value == AnnouncementStatusEnum.Stop
|
? currentTime > x.EndTime
|
: false)
|
.Select(x =>
|
new CreateEditLifePayAnnouncementOutput()
|
{
|
Id = x.Id,
|
AnnouncementType = x.AnnouncementType,
|
StartTime = x.StartTime,
|
EndTime = x.EndTime,
|
AnnouncementContent = x.AnnouncementContent,
|
CreationTime = x.CreationTime,
|
Status = GetLifePayAnnouncementStatus(x.StartTime, x.EndTime)
|
});
|
|
var result = await query.GetPageResult(input.PageModel);
|
|
return result;
|
}
|
|
/// <summary>
|
/// 新增编辑公告
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
public async Task<int> CreateOrEditLifePayAnnouncement(CreateEditLifePayAnnouncementInput input)
|
{
|
CheckExtensions.IfTrueThrowUserFriendlyException(input.EndTime <= input.StartTime, "截止日期不能低于生效日期");
|
|
bool isExist = await _lifePayAnnouncementRepository.AnyAsync(r => (!input.Id.HasValue||r.Id != input.Id.Value)&&input.AnnouncementType==r.AnnouncementType&&!(input.EndTime < r.StartTime || input.StartTime > r.EndTime));
|
CheckExtensions.IfTrueThrowUserFriendlyException(isExist, "同一时间段只能存在一条公告");
|
|
|
if (input.Id.HasValue)
|
{
|
|
var dto = await _lifePayAnnouncementRepository.FirstOrDefaultAsync(r => r.Id == input.Id.Value);
|
CheckExtensions.IfTrueThrowUserFriendlyException(dto == null, "未获取到公告数据");
|
|
dto.AnnouncementType = input.AnnouncementType;
|
dto.StartTime = input.StartTime;
|
dto.EndTime = input.EndTime;
|
dto.AnnouncementContent = input.AnnouncementContent;
|
}
|
else
|
{
|
input.Id = Guid.NewGuid();
|
var entity = ObjectMapper.Map<CreateEditLifePayAnnouncementInput, LifePayAnnouncement>(input);
|
await _lifePayAnnouncementRepository.InsertAsync(entity);
|
}
|
|
return Constant.SUCCESS;
|
}
|
|
/// <summary>
|
/// 删除公告
|
/// </summary>
|
/// <param name="id"></param>
|
/// <returns></returns>
|
public async Task<int> DeleteLifePayAnnouncement(Guid id)
|
{
|
await _lifePayAnnouncementRepository.DeleteAsync(s => s.Id == id);
|
|
return Constant.SUCCESS;
|
}
|
|
/// <summary>
|
/// 获取当前展示中的公告
|
/// </summary>
|
/// <returns></returns>
|
public async Task<CreateEditLifePayAnnouncementOutput> GetShowingLifePayAnnouncement(GetShowingLifePayAnnouncementInput input)
|
{
|
DateTime now = DateTime.Now;
|
var announcement = await _lifePayAnnouncementRepository
|
.WhereIf(input.AnnouncementType.HasValue,x=>x.AnnouncementType==input.AnnouncementType)
|
.Where(x => now >= x.StartTime && now <= x.EndTime).OrderBy(r => r.StartTime).FirstOrDefaultAsync();
|
if (announcement == null)
|
{
|
return null;
|
}
|
|
var model = ObjectMapper.Map<LifePayAnnouncement, CreateEditLifePayAnnouncementOutput>(announcement);
|
model.Status = GetLifePayAnnouncementStatus(announcement.StartTime, announcement.EndTime);
|
return model;
|
}
|
|
private static AnnouncementStatusEnum GetLifePayAnnouncementStatus(DateTime startTime, DateTime endTime)
|
{
|
DateTime now = DateTime.Now;
|
if (now < startTime)
|
{
|
return AnnouncementStatusEnum.Wait;
|
}
|
else if (now >= startTime && now <= endTime)
|
{
|
return AnnouncementStatusEnum.Showing;
|
}
|
else
|
{
|
return AnnouncementStatusEnum.Stop;
|
}
|
}
|
}
|
