ewide/number_zj
22
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

init commit

Browse Source
This commit is contained in:
路 范
2022-03-30 17:54:33 +08:00
parent df01841625
commit 904bdd16cd
500 changed files with 217251 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

99
20220330_Vote/Ewide.Core/Service/Dict/Dto/DictDataInput.cs Normal file
View File

@@ -0,0 +1,99 @@
using Furion.DataValidation;
using System.ComponentModel.DataAnnotations;
namespace Ewide.Core.Service
{
/// <summary>
/// 字典值参数
/// </summary>
public class DictDataInput : PageInputBase
{
/// <summary>
/// 字典类型Id
/// </summary>
public virtual string TypeId { get; set; }
/// <summary>
/// 值
/// </summary>
public virtual string Value { get; set; }
/// <summary>
/// 编码
/// </summary>
public virtual string Code { get; set; }
/// <summary>
/// 扩展编码
/// </summary>
public virtual string ExtCode { get; set; }
/// <summary>
/// 排序
/// </summary>
public virtual int Sort { get; set; }
/// <summary>
/// 备注
/// </summary>
public virtual string Remark { get; set; }
/// <summary>
/// 状态（字典 0正常 1停用 2删除）
/// </summary>
public virtual CommonStatus Status { get; set; }
}
public class QueryDictDataListInput
{
/// <summary>
/// 字典类型Id
/// </summary>
[Required(ErrorMessage = "字典类型Id不能为空")]
public string TypeId { get; set; }
}
public class AddDictDataInput : DictDataInput
{
/// <summary>
/// 字典类型Id
/// </summary>
[Required(ErrorMessage = "字典类型Id不能为空")]
public override string TypeId { get; set; }
/// <summary>
/// 值
/// </summary>
[Required(ErrorMessage = "字典值不能为空")]
public override string Value { get; set; }
/// <summary>
/// 编码
/// </summary>
[Required(ErrorMessage = "字典值编码不能为空")]
public override string Code { get; set; }
}
public class DeleteDictDataInput
{
/// <summary>
/// 字典值Id
/// </summary>
[Required(ErrorMessage = "字典值Id不能为空")]
public string Id { get; set; }
}
public class UpdateDictDataInput : AddDictDataInput
{
/// <summary>
/// 字典值Id
/// </summary>
[Required(ErrorMessage = "字典值Id不能为空")]
public string Id { get; set; }
}
public class QueryDictDataInput : DeleteDictDataInput
{
}
}

13
20220330_Vote/Ewide.Core/Service/Dict/Dto/DictDataOutput.cs Normal file
View File

@@ -0,0 +1,13 @@
namespace Ewide.Core.Service
{
/// <summary>
/// 字典值参数
/// </summary>
public class DictDataOutput : DictDataInput
{
/// <summary>
/// 字典Id
/// </summary>
public virtual string Id { get; set; }
}
}

108
20220330_Vote/Ewide.Core/Service/Dict/Dto/DictTreeOutput.cs Normal file
View File

@@ -0,0 +1,108 @@
using System.Collections;
using System.Collections.Generic;
namespace Ewide.Core.Service
{
/// <summary>
/// 字典类型与字典值构造的树
/// </summary>
public class DictTreeOutput : ITreeNode
{
/// <summary>
/// Id
/// </summary>
public string Id { get; set; }
/// <summary>
/// 父Id
/// </summary>
public string Pid { get; set; }
/// <summary>
/// 编码-对应字典值的编码
/// </summary>
public string Code { get; set; }
/// <summary>
/// 名称-对应字典值的value
/// </summary>
public string Name { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { set; get; }
/// <summary>
/// 排序
/// </summary>
public int Sort { set; get; }
/// <summary>
/// 子节点集合
/// </summary>
public List<DictTreeOutput> Children { get; set; } = new List<DictTreeOutput>();
public string GetId()
{
return Id;
}
public string GetPid()
{
return Pid;
}
public void SetChildren(IList children)
{
Children = (List<DictTreeOutput>)children;
}
}
public class DictTreeNode : ITreeNode
{
/// <summary>
/// Id
/// </summary>
public string Id { get; set; }
/// <summary>
/// 父Id
/// </summary>
public string ParentId { get; set; }
/// <summary>
/// 名称
/// </summary>
public string Title { get; set; }
/// <summary>
/// 值
/// </summary>
public string Value { get; set; }
/// <summary>
/// 排序，越小优先级越高
/// </summary>
public int Weight { get; set; }
/// <summary>
/// 子节点
/// </summary>
public List<DictTreeNode> Children { get; set; } = new List<DictTreeNode>();
public string GetId()
{
return Id;
}
public string GetPid()
{
return ParentId;
}
public void SetChildren(IList children)
{
Children = (List<DictTreeNode>)children;
}
}
}

98
20220330_Vote/Ewide.Core/Service/Dict/Dto/DictTypeInput.cs Normal file
View File

@@ -0,0 +1,98 @@
using System.ComponentModel.DataAnnotations;
namespace Ewide.Core.Service
{
/// <summary>
/// 字典类型参数
/// </summary>
public class DictTypeInput : PageInputBase
{
public string Pid { get; set; }
/// <summary>
/// 名称
/// </summary>
public virtual string Name { get; set; }
/// <summary>
/// 编码
/// </summary>
public virtual string Code { get; set; }
public int Type { get; set; }
/// <summary>
/// 排序
/// </summary>
public virtual int Sort { get; set; }
/// <summary>
/// 备注
/// </summary>
public virtual string Remark { get; set; }
/// <summary>
/// 状态（字典 0正常 1停用 2删除）
/// </summary>
public virtual CommonStatus Status { get; set; }
}
public class AddDictTypeInput : DictTypeInput
{
/// <summary>
/// 父Id
/// </summary>
public string Pid { get; set; }
/// <summary>
/// 名称
/// </summary>
[Required(ErrorMessage = "字典类型名称不能为空")]
public override string Name { get; set; }
/// <summary>
/// 编码
/// </summary>
public override string Code { get; set; }
}
public class DeleteDictTypeInput
{
/// <summary>
/// 编号Id
/// </summary>
[Required(ErrorMessage = "字典类型Id不能为空")]
public string Id { get; set; }
}
public class UpdateDictTypeInput : AddDictTypeInput
{
/// <summary>
/// Id
/// </summary>
[Required(ErrorMessage = "字典类型Id不能为空")]
public string Id { get; set; }
}
public class DropDownDictTypeInput
{
/// <summary>
/// 编码
/// </summary>
[Required(ErrorMessage = "字典类型编码不能为空")]
public string Code { get; set; }
}
public class DropDownDictTypesInput
{
/// <summary>
/// 编码
/// </summary>
[Required(ErrorMessage = "字典类型编码不能为空")]
public string[] Code { get; set; }
}
public class QueryDictTypeInfoInput : DeleteDictTypeInput
{
}
}

23
20220330_Vote/Ewide.Core/Service/Dict/Dto/EnumDictOutput.cs Normal file
View File

@@ -0,0 +1,23 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Ewide.Core.Service.Dict.Dto
{
public class EnumDictOutput
{
public string FullName { get; set; }
public string Desc { get; set; }
public string Code { get; set; }
public List<EnumDictData> Datas { get; set; }
}
public class EnumDictData
{
public string Desc { get; set; }
public string Code { get; set; }
public string Value { get; set; }
}
}

20
20220330_Vote/Ewide.Core/Service/Dict/ISysDictDataService.cs Normal file
View File

@@ -0,0 +1,20 @@
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
namespace Ewide.Core.Service
{
public interface ISysDictDataService
{
Task AddDictData(AddDictDataInput input);
Task ChangeDictDataStatus(UpdateDictDataInput input);
Task DeleteByTypeId(string dictTypeId);
Task DeleteDictData(DeleteDictDataInput input);
Task<dynamic> GetDictData([FromQuery] QueryDictDataInput input);
Task<dynamic> GetDictDataList([FromQuery] QueryDictDataListInput input);
Task<dynamic> GetDictDataListByDictTypeId(string dictTypeId);
Task<dynamic> GetDictDataListByDictTypeIds(SysDictType[] dictTypes);
Task<dynamic> QueryDictDataPageList([FromQuery] DictDataInput input);
Task DeleteDictDataBatch(string[] Ids);
Task UpdateDictData(UpdateDictDataInput input);
}
}

22
20220330_Vote/Ewide.Core/Service/Dict/ISysDictTypeService.cs Normal file
View File

@@ -0,0 +1,22 @@
using Ewide.Core.Service.Dict.Dto;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Ewide.Core.Service
{
public interface ISysDictTypeService
{
Task AddDictType(AddDictTypeInput input);
Task ChangeDictTypeStatus(UpdateDictTypeInput input);
Task DeleteDictType(DeleteDictTypeInput input);
Task<List<DictTreeNode>> GetDictTree();
Task<dynamic> GetDictType([FromQuery] QueryDictTypeInfoInput input);
Task<dynamic> GetDictTypeDropDown([FromQuery] DropDownDictTypeInput input);
Task<dynamic> GetDictTypeDropDowns([FromQuery] DropDownDictTypesInput input);
Task<dynamic> GetDictTypeList();
Task<dynamic> QueryDictTypePageList([FromQuery] DictTypeInput input);
Task UpdateDictType(UpdateDictTypeInput input);
Task<List<EnumDictOutput>> GetEnumDictDataList([FromQuery] DictTypeInput input);
}
}

231
20220330_Vote/Ewide.Core/Service/Dict/SysDictDataService.cs Normal file
View File

@@ -0,0 +1,231 @@
using Furion.DatabaseAccessor;
using Ewide.Core.Extension;
using Furion.DatabaseAccessor.Extensions;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
namespace Ewide.Core.Service
{
/// <summary>
/// 字典值服务
/// </summary>
[ApiDescriptionSettings(Name = "DictData", Order = 100)]
public class SysDictDataService : ISysDictDataService, IDynamicApiController, ITransient
{
private readonly IRepository<SysDictData> _sysDictDataRep; // 字典类型表仓储
private readonly IRepository<SysDictType> _sysDictTypeRep;
public SysDictDataService(IRepository<SysDictData> sysDictDataRep, IRepository<SysDictType> sysDictTypeRep)
{
_sysDictTypeRep = sysDictTypeRep;
_sysDictDataRep = sysDictDataRep;
}
/// <summary>
/// 分页查询字典值
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysDictData/page")]
public async Task<dynamic> QueryDictDataPageList([FromBody] DictDataInput input)
{
var code = !string.IsNullOrEmpty(input.Code?.Trim());
var value = !string.IsNullOrEmpty(input.Value?.Trim());
var dictDatas = await _sysDictDataRep.DetachedEntities
.Where(u => u.TypeId == input.TypeId)
.Where((code, u => EF.Functions.Like(u.Code, $"%{input.Code.Trim()}%")),
(value, u => EF.Functions.Like(u.Value, $"%{input.Value.Trim()}%")))
.Where(u => u.Status != CommonStatus.DELETED).OrderBy(u => u.Sort)
//.Select(u => u.Adapt<DictDataOutput>())
// .ToPagedListAsync(input.PageNo, input.PageSize)
.ToPageData<SysDictData, DictDataOutput>(input);
return PageDataResult<DictDataOutput>.PageResult(dictDatas);
}
/// <summary>
/// 获取某个字典类型下字典值列表
/// </summary>
/// <returns></returns>
[HttpGet("/sysDictData/list")]
public async Task<dynamic> GetDictDataList([FromQuery] QueryDictDataListInput input)
{
return await _sysDictDataRep.DetachedEntities.Where(u => u.TypeId == input.TypeId).Where(u => u.Status != CommonStatus.DELETED).OrderBy(u => u.Sort).ToListAsync();
}
/// <summary>
/// 增加字典值
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysDictData/add")]
public async Task AddDictData(AddDictDataInput input)
{
var isExist = await _sysDictDataRep.AnyAsync(u => (u.Code == input.Code || u.Value == input.Value) && u.TypeId == input.TypeId, false);
if (isExist) throw Oops.Oh(ErrorCode.D3003);
//datatype 的code 为null 则不能添加
var dataType = _sysDictTypeRep.Where(s => s.Id == input.TypeId).FirstOrDefault();
if (string.IsNullOrEmpty(dataType.Code)) throw Oops.Oh("此处类型不能添加数据");
input.ExtCode = CheckExtCode(input.ExtCode);
var dictData = input.Adapt<SysDictData>();
await _sysDictDataRep.InsertAsync(dictData);
}
/// <summary>
/// 删除字典值
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysDictData/delete")]
public async Task DeleteDictData(DeleteDictDataInput input)
{
var dictData = await _sysDictDataRep.FirstOrDefaultAsync(u => u.Id == input.Id);
if (dictData == null) throw Oops.Oh(ErrorCode.D3004);
await dictData.DeleteAsync();
}
/// <summary>
/// 删除字典值 id数组传入
/// </summary>
/// <param name="ids"></param>
/// <returns></returns>
[HttpPost("/sysDictData/deleteBatch")]
public async Task DeleteDictDataBatch([FromBody] string[] ids)
{
var dictDataList = await _sysDictDataRep.Where(s => ids.Contains(s.Id)).ToListAsync();
if (dictDataList.Count == 0) throw Oops.Oh(ErrorCode.D3004);
dictDataList.ForEach(s =>
{
s.DeleteAsync();
});
}
/// <summary>
/// 更新字典值
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysDictData/edit")]
public async Task UpdateDictData(UpdateDictDataInput input)
{
var isExist = await _sysDictDataRep.AnyAsync(u => u.Id == input.Id, false);
if (!isExist) throw Oops.Oh(ErrorCode.D3004);
// 排除自己并且判断与其他是否相同
isExist = await _sysDictDataRep.AnyAsync(u => (u.Value == input.Value || u.Code == input.Code) && u.TypeId == input.TypeId && u.Id != input.Id, false);
if (isExist) throw Oops.Oh(ErrorCode.D3003);
input.ExtCode = CheckExtCode(input.ExtCode);
var dictData = input.Adapt<SysDictData>();
await _sysDictDataRep.UpdateAsync(dictData, ignoreNullValues: true);
}
/// <summary>
/// 字典值详情
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpGet("/sysDictData/detail")]
public async Task<dynamic> GetDictData([FromQuery] QueryDictDataInput input)
{
return await _sysDictDataRep.FirstOrDefaultAsync(u => u.Id == input.Id, false);
}
/// <summary>
/// 修改字典值状态
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysDictData/changeStatus")]
public async Task ChangeDictDataStatus(UpdateDictDataInput input)
{
var dictData = await _sysDictDataRep.FirstOrDefaultAsync(u => u.Id == input.Id);
if (dictData == null) throw Oops.Oh(ErrorCode.D3004);
if (!Enum.IsDefined(typeof(CommonStatus), input.Status))
throw Oops.Oh(ErrorCode.D3005);
dictData.Status = input.Status;
}
/// <summary>
/// 根据字典类型Id获取字典值集合
/// </summary>
/// <param name="dictTypeId"></param>
/// <returns></returns>
[NonAction]
public async Task<dynamic> GetDictDataListByDictTypeId(string dictTypeId)
{
return await _sysDictDataRep.DetachedEntities.Where(u => u.SysDictType.Id == dictTypeId)
.Where(u => u.Status != CommonStatus.DELETED).OrderBy(u => u.Sort)
.Select(u => new
{
u.Code,
u.Value,
ExtCode = String.IsNullOrEmpty(u.ExtCode) ? null : Newtonsoft.Json.JsonConvert.DeserializeObject<object>(u.ExtCode),
u.Remark
}).ToListAsync();
}
[NonAction]
public async Task<dynamic> GetDictDataListByDictTypeIds(SysDictType[] dictTypes)
{
var dictTypeIds = dictTypes.Select(u => u.Id);
var dictData = await _sysDictDataRep.DetachedEntities.Where(u => dictTypeIds.Contains(u.SysDictType.Id))
.Where(u => u.Status != CommonStatus.DELETED).OrderBy(u => u.Sort)
.ToListAsync();
var result = new Dictionary<string, dynamic>();
foreach (var dictType in dictTypes)
{
result.Add(dictType.Code, dictData.Where(u => u.TypeId == dictType.Id)
.Select(u => new
{
u.Code,
u.Value,
ExtCode = String.IsNullOrEmpty(u.ExtCode) ? null : Newtonsoft.Json.JsonConvert.DeserializeObject<object>(u.ExtCode),
u.Remark
}));
}
return result;
}
/// <summary>
/// 删除字典下所有值
/// </summary>
/// <param name="dictTypeId"></param>
[NonAction]
public async Task DeleteByTypeId(string dictTypeId)
{
var dictDatas = await _sysDictDataRep.Where(u => u.TypeId == dictTypeId).ToListAsync();
dictDatas.ForEach(u =>
{
u.Delete();
});
}
[NonAction]
private string CheckExtCode(string extCode)
{
if (!string.IsNullOrEmpty(extCode))
{
try
{
if (extCode.StartsWith('{') && extCode.EndsWith('}'))
{
return Newtonsoft.Json.JsonConvert.SerializeObject(Newtonsoft.Json.JsonConvert.DeserializeObject(extCode));
}
}
catch { }
}
return null;
}
}
}

250
20220330_Vote/Ewide.Core/Service/Dict/SysDictTypeService.cs Normal file
View File

@@ -0,0 +1,250 @@
using Ewide.Core.Extension;
using Ewide.Core.Service.Dict.Dto;
using Furion.DatabaseAccessor;
using Furion.DatabaseAccessor.Extensions;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using Mapster;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
namespace Ewide.Core.Service
{
/// <summary>
/// 字典类型服务
/// </summary>
[ApiDescriptionSettings(Name = "DictType", Order = 100)]
public class SysDictTypeService : ISysDictTypeService, IDynamicApiController, ITransient
{
private readonly IRepository<SysDictType> _sysDictTypeRep; // 字典类型表仓储
private readonly ISysDictDataService _sysDictDataService;
public SysDictTypeService(ISysDictDataService sysDictDataService,
IRepository<SysDictType> sysDictTypeRep)
{
_sysDictDataService = sysDictDataService;
_sysDictTypeRep = sysDictTypeRep;
}
/// <summary>
/// 分页查询字典类型
/// </summary>
/// <returns></returns>
[HttpPost("/sysDictType/page")]
public async Task<dynamic> QueryDictTypePageList([FromBody] DictTypeInput input)
{
var code = !string.IsNullOrEmpty(input.Code?.Trim());
var name = !string.IsNullOrEmpty(input.Name?.Trim());
var pId = !string.IsNullOrEmpty(input.Pid?.Trim());
var type = input.Type > 0;
var dictTypes = await _sysDictTypeRep.DetachedEntities
.Where(pId, u => EF.Functions.Like(u.Pids, $"%[{input.Pid.Trim()}]%") || u.Id == input.Pid.Trim())
.Where((code, u => EF.Functions.Like(u.Code, $"%{input.Code.Trim()}%")),
(name, u => EF.Functions.Like(u.Name, $"%{input.Name.Trim()}%")))
.Where(type, u => input.Type == 1 ? string.IsNullOrEmpty(u.Code) : !string.IsNullOrEmpty(u.Code))
.Where(u => u.Status != CommonStatus.DELETED).OrderBy(u => u.Sort)
//.ToPagedListAsync(input.PageNo, input.PageSize);
.ToPageData(input);
return PageDataResult<SysDictType>.PageResult(dictTypes);
}
/// <summary>
/// 获取字典类型列表
/// </summary>
/// <returns></returns>
[HttpGet("/sysDictType/list")]
public async Task<dynamic> GetDictTypeList()
{
return await _sysDictTypeRep.DetachedEntities.Where(u => u.Status != CommonStatus.DELETED).ToListAsync();
}
/// <summary>
/// 获取字典类型下所有字典值
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpGet("/sysDictType/dropDown")]
public async Task<dynamic> GetDictTypeDropDown([FromQuery] DropDownDictTypeInput input)
{
var dictType = await _sysDictTypeRep.FirstOrDefaultAsync(u => u.Code == input.Code, false);
if (dictType == null) throw Oops.Oh(ErrorCode.D3000);
return await _sysDictDataService.GetDictDataListByDictTypeId(dictType.Id);
}
/// <summary>
///
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpGet("/sysDictType/dropDowns")]
public async Task<dynamic> GetDictTypeDropDowns([FromQuery] DropDownDictTypesInput input)
{
var dictTypes = await _sysDictTypeRep.Where(u => input.Code.Contains(u.Code), false).ToArrayAsync();
if (dictTypes.Length == 0) throw Oops.Oh(ErrorCode.D3000);
return await _sysDictDataService.GetDictDataListByDictTypeIds(dictTypes);
}
/// <summary>
/// 添加字典类型
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysDictType/add")]
public async Task AddDictType(AddDictTypeInput input)
{
var isExist = await _sysDictTypeRep.AnyAsync(u => u.Name == input.Name, false);
if (isExist) throw Oops.Oh(ErrorCode.D3001);
var dictTypeEntity = _sysDictTypeRep.Where(s => s.Id == input.Pid).FirstOrDefault();
if (dictTypeEntity != null && dictTypeEntity.Code != null) throw new Exception("此类型下不能添加子类型");
var dictType = input.Adapt<SysDictType>();
dictType.Pids = await CreateNewPids(input.Pid);
if (input.Code == string.Empty) dictType.Code = null;
await _sysDictTypeRep.InsertAsync(dictType);
}
/// <summary>
/// 删除字典类型
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysDictType/delete")]
public async Task DeleteDictType(DeleteDictTypeInput input)
{
var dictType = await _sysDictTypeRep.FirstOrDefaultAsync(u => u.Id == input.Id);
if (dictType == null) throw Oops.Oh(ErrorCode.D3000);
var dictDatas = await _sysDictDataService.GetDictDataListByDictTypeId(input.Id); //_sysDictDataService.DeleteByTypeId(input.Id);
if (dictDatas != null && dictDatas.Count > 0) throw Oops.Oh(ErrorCode.D3002);
await dictType.DeleteAsync();
}
/// <summary>
/// 更新字典类型
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysDictType/edit"),]
public async Task UpdateDictType(UpdateDictTypeInput input)
{
var isExist = await _sysDictTypeRep.AnyAsync(u => u.Id == input.Id, false);
if (!isExist) throw Oops.Oh(ErrorCode.D3000);
if (input.Id == input.Pid) throw Oops.Oh(ErrorCode.D4006);
// 排除自己并且判断与其他是否相同
isExist = await _sysDictTypeRep.AnyAsync(u => (u.Name == input.Name || u.Code == input.Code) && u.Id != input.Id, false);
if (isExist) throw Oops.Oh(ErrorCode.D3001);
var dictType = input.Adapt<SysDictType>();
dictType.Pids = await CreateNewPids(input.Pid);
dictType.Code = input.Code == string.Empty ? null : input.Code;
await dictType.UpdateIncludeAsync(new string[] { nameof(SysDictType.Pid), nameof(SysDictType.Pids), nameof(SysDictType.Name), nameof(SysDictType.Code), nameof(SysDictType.Sort), nameof(SysDictType.Remark) }, false);
}
/// <summary>
/// 字典类型详情
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpGet("/sysDictType/detail")]
public async Task<dynamic> GetDictType([FromQuery] QueryDictTypeInfoInput input)
{
return await _sysDictTypeRep.FirstOrDefaultAsync(u => u.Id == input.Id, false);
}
/// <summary>
/// 更新字典类型状态
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost("/sysDictType/changeStatus")]
public async Task ChangeDictTypeStatus(UpdateDictTypeInput input)
{
var dictType = await _sysDictTypeRep.FirstOrDefaultAsync(u => u.Id == input.Id);
if (dictType == null) throw Oops.Oh(ErrorCode.D3000);
if (!Enum.IsDefined(typeof(CommonStatus), input.Status))
throw Oops.Oh(ErrorCode.D3005);
dictType.Status = input.Status;
}
/// <summary>
/// 字典类型与字典值构造的字典树
/// </summary>
/// <returns></returns>
[AllowAnonymous]
[HttpGet("/sysDictType/tree")]
public async Task<List<DictTreeNode>> GetDictTree()
{
var DictTypeList = await _sysDictTypeRep.AsQueryable().Where(p => string.IsNullOrEmpty(p.Code)).ToListAsync();
return new TreeBuildUtil<DictTreeNode>().DoTreeBuild(DictTypeList
.OrderBy(s => s.Sort)
.Select(u => new DictTreeNode
{
Title = u.Name,
ParentId = u.Pid,
Id = u.Id,
Value = u.Id
}).ToList());
}
/// <summary>
/// 创建Pids格式
/// 如果pid是0顶级节点，pids就是 [0];
/// 如果pid不是顶级节点，pids就是 pid菜单的 pids + [pid] + ,
/// </summary>
/// <param name="pid"></param>
/// <returns></returns>
private async Task<string> CreateNewPids(string pid)
{
if (pid.Equals(System.Guid.Empty.ToString()))
{
return "[" + System.Guid.Empty + "],";
}
else
{
var dtype = await _sysDictTypeRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == pid);
return dtype.Pids + "[" + pid + "],";
}
}
[HttpGet("/sysDictType/enumDictList")]
public Task<List<EnumDictOutput>> GetEnumDictDataList([FromQuery] DictTypeInput input)
{
var typeList = Assembly.GetExecutingAssembly().GetTypes().Where(t => t.IsEnum);
typeList = typeList.Concat(Assembly.Load("Ewide.Application").GetTypes().Where(t => t.IsEnum));
var list = new List<EnumDictOutput>();
foreach (var type in typeList)
{
var dictType = new EnumDictOutput
{
Desc = type.GetCustomAttribute<DescriptionAttribute>()?.Description,
FullName = type.FullName,
Code = type.Name,
Datas = new List<EnumDictData>(),
};
var fields = type.GetFields(BindingFlags.Static | BindingFlags.Public);
foreach (var field in fields)
{
var value = field.GetValue(null);
var dictData = new EnumDictData
{
Desc = field.GetCustomAttribute<DescriptionAttribute>()?.Description,
Code = field.Name,
Value = Convert.ChangeType(value, Enum.GetUnderlyingType(value.GetType())).ToString(),
};
dictType.Datas.Add(dictData);
}
list.Add(dictType);
}
return Task.FromResult(list);
}
}
}