//--------------------------------------------------------------------
// 此代码由T4模板自动生成 byzhouhang 20210918
// 生成时间 2023-06-01 13:42:25
// 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
//--------------------------------------------------------------------
using IRaCIS.Core.Application.Helper;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.ViewModel;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using ZiggyCreatures.Caching.Fusion;
namespace IRaCIS.Core.Application.Service
{
/// <summary>
/// InternationalizationService
/// </summary>
[ApiExplorerSettings(GroupName = "Common")]
public class InternationalizationService(IRepository<Internationalization> _internationalizationRepository,
IMapper _mapper, IRepository<PublishLog> _publishLogRepository, IStringLocalizer _localizer, IFusionCache _fusionCache) : BaseService, IInternationalizationService
{
/// <summary>
/// 前端国际化内容接口
/// </summary>
/// <returns></returns>
[AllowAnonymous]
[HttpGet]
public async Task<IEnumerable<InternationalizationSimpleDto>> GetFrontInternationalizationList()
{
var cacheList = await _fusionCache.GetOrDefaultAsync<List<InternationalizationSimpleDto>>(CacheKeys.FrontInternational);
//if(cacheList != null && cacheList.Count!=0)
//{
// return cacheList;
//}
//else
{
var list = await _internationalizationRepository.Where(t => t.InternationalizationType == 0).Select(t => new InternationalizationSimpleDto()
{
Code = t.Code,
Value = t.Value,
ValueCN = t.ValueCN,
FrontType = t.FrontType,
Description = t.Description,
Module = t.Module,
State = t.State,
Version = t.PublishLog.Version,
CreateTime = t.CreateTime,
InternationalizationType = t.InternationalizationType
}).ToListAsync();
await _fusionCache.SetAsync<List<InternationalizationSimpleDto>>(CacheKeys.FrontInternational, list, TimeSpan.FromDays(1));
return list;
}
}
/// <summary>
/// 前端批量提交，后端查询判断不存在就添加，存在就更新 （这里提交接口也能提交后端的标识，对后端标识进行更新）
/// </summary>
/// <returns></returns>
[AllowAnonymous]
public async Task<IResponseOutput> BatchAddOrUpdateFrontInternationalization(List<BatchInternationalizationDto> batchList)
{
var result = (await _publishLogRepository.Where(t => t.IsCurrentVersion == true).ProjectTo<PublishLogView>(_mapper.ConfigurationProvider).FirstOrDefaultAsync()).IfNullThrowException();
foreach (var item in batchList)
{
var find = await _internationalizationRepository.FirstOrDefaultAsync(t => t.Code == item.Code && t.InternationalizationType == item.InternationalizationType);
if (find != null)
{
_mapper.Map(item, find);
}
else
{
var frontState = item.State == null ? 0 : (int)item.State;
var mapItem = _mapper.Map<Internationalization>(item);
//mapItem.InternationalizationType = 0;
// 0 是预翻译 1是已确认 2是后端废弃
mapItem.State = frontState;
find = await _internationalizationRepository.AddAsync(mapItem);
}
if (find.PublishLogId == null || find.PublishLogId == Guid.Empty)
{
find.PublishLogId = result.Id;
}
}
await _internationalizationRepository.SaveChangesAsync();
//清理缓存
await _fusionCache.SetAsync<List<InternationalizationSimpleDto>>(CacheKeys.FrontInternational, new List<InternationalizationSimpleDto>(), TimeSpan.FromDays(1));
return ResponseOutput.Ok();
}
[HttpPost]
public async Task<PageOutput<InternationalizationView>> GetInternationalizationList(InternationalizationQuery inQuery)
{
var internationalizationQueryable = _internationalizationRepository
.WhereIf(inQuery.Description != null, t => t.Description.Contains(inQuery.Description))
.WhereIf(inQuery.Module != null, t => t.Module.Contains(inQuery.Module))
.WhereIf(inQuery.PublishLogId != null, t => t.PublishLogId == inQuery.PublishLogId)
.WhereIf(inQuery.Code != null, t => t.Code.Contains(inQuery.Code))
.WhereIf(inQuery.State != null, t => t.State == inQuery.State)
.WhereIf(inQuery.InternationalizationType != null, t => t.InternationalizationType == inQuery.InternationalizationType)
.WhereIf(inQuery.Value != null, t => t.Value.Contains(inQuery.Value))
.WhereIf(inQuery.ValueCN != null, t => t.ValueCN.Contains(inQuery.ValueCN))
.WhereIf(inQuery.BeginCreateTime != null, t => t.CreateTime >= inQuery.BeginCreateTime)
.WhereIf(inQuery.EndCreatTime != null, t => t.CreateTime <= inQuery.EndCreatTime)
.WhereIf(inQuery.BeginUpdateTime != null, t => t.UpdateTime >= inQuery.BeginUpdateTime)
.WhereIf(inQuery.EndUpdateTime != null, t => t.UpdateTime <= inQuery.EndUpdateTime)
.ProjectTo<InternationalizationView>(_mapper.ConfigurationProvider);
var pageList = await internationalizationQueryable
.ToPagedListAsync(inQuery);
return pageList;
}
/// <summary>
/// 后端之前批量添加接口
/// </summary>
/// <param name="batchAdd"></param>
/// <returns></returns>
[HttpPost]
public async Task<IResponseOutput> BatchAddInternationalization(BatchAddInternationalization batchAdd)
{
foreach (var item in batchAdd.AddList)
{
var mapItem = _mapper.Map<InternationalizationAddOrEdit>(item);
mapItem.InternationalizationType = batchAdd.InternationalizationType;
mapItem.State = batchAdd.State;
var verifyExp1 = new EntityVerifyExp<Internationalization>()
{
VerifyExp = t => t.Code == mapItem.Code && t.InternationalizationType == mapItem.InternationalizationType,
VerifyMsg = $"该类型已有{item.Code}名称的国际化标识",
IsVerify = true
};
var entity = await _internationalizationRepository.InsertOrUpdateAsync(mapItem, false, verifyExp1);
}
await _internationalizationRepository.SaveChangesAsync();
//清理缓存
await _fusionCache.SetAsync<List<InternationalizationSimpleDto>>(CacheKeys.FrontInternational, new List<InternationalizationSimpleDto>(), TimeSpan.FromDays(1));
return ResponseOutput.Ok();
}
/// <summary>
/// 前后端添加的时候，区分了，前端判断重复多了多了一个路由 路由+标识唯一
/// </summary>
/// <param name="addOrEditInternationalization"></param>
/// <returns></returns>
public async Task<IResponseOutput> AddOrUpdateInternationalization(InternationalizationAddOrEdit addOrEditInternationalization)
{
var internationalizationType = addOrEditInternationalization.InternationalizationType;
//后端验证标识重复与否
var verifyExp1 = new EntityVerifyExp<Internationalization>()
{
VerifyExp = t => t.Code == addOrEditInternationalization.Code && t.InternationalizationType == addOrEditInternationalization.InternationalizationType,
VerifyMsg = $"该类型已有{addOrEditInternationalization.Code}名称的国际化标识",
IsVerify = true /*internationalizationType == 1*/
};
//前端验证标识重复与否
//var verifyExp2 = new EntityVerifyExp<Internationalization>()
//{
// VerifyExp = t => t.Code == addOrEditInternationalization.Code && t.InternationalizationType == addOrEditInternationalization.InternationalizationType && t.Description == addOrEditInternationalization.Description,
// VerifyMsg = $"该类型已有{addOrEditInternationalization.Description}下的{addOrEditInternationalization.Code}名称的国际化标识",
// IsVerify = internationalizationType == 0
//};
var entity = await _internationalizationRepository.InsertOrUpdateAsync(addOrEditInternationalization, true, verifyExp1/*, verifyExp2*/);
if (addOrEditInternationalization.InternationalizationType == 1)
{
await InternationalizationHelper.AddOrUpdateJsonKeyValueAsync(_mapper.Map<IRCGlobalInfoDTO>(addOrEditInternationalization));
}
else
{
//清理缓存
await _fusionCache.SetAsync<List<InternationalizationSimpleDto>>(CacheKeys.FrontInternational, new List<InternationalizationSimpleDto>(), TimeSpan.FromDays(1));
}
return ResponseOutput.Ok(entity.Id.ToString());
}
[HttpDelete("{internationalizationId:guid}")]
public async Task<IResponseOutput> DeleteInternationalization(Guid internationalizationId)
{
var success = await _internationalizationRepository.DeleteFromQueryAsync(t => t.Id == internationalizationId, true);
//清理缓存
await _fusionCache.SetAsync<List<InternationalizationSimpleDto>>(CacheKeys.FrontInternational, new List<InternationalizationSimpleDto>(), TimeSpan.FromDays(1));
return ResponseOutput.Ok();
}
/// <summary>
/// 批量更新状态和发布版本
/// </summary>
/// <param name="inCommand"></param>
/// <returns></returns>
[HttpPut]
public async Task<IResponseOutput> BatchUpdateInternationalInfo(BatchUpdateInfoCommand inCommand)
{
await _internationalizationRepository.BatchUpdateNoTrackingAsync(t => inCommand.IdList.Contains(t.Id), t => new Internationalization() { State = inCommand.State, PublishLogId = inCommand.PublishLogId });
return ResponseOutput.Ok();
}
}
}