Zel/WaterCloudForJt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加项目文件。

Browse Source
This commit is contained in:
zel
2025-03-05 19:42:01 +08:00
parent 659f1a2ad9
commit 47dcdeb55d
582 changed files with 242004 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
WaterCloud.Service/SystemManage/AreaService.cs Normal file
View File

@@ -0,0 +1,82 @@
/*******************************************************************************
* Copyright © 2020 WaterCloud.Framework 版权所有
* Author: WaterCloud
* Description: WaterCloud快速开发平台
* Website：
*********************************************************************************/
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using WaterCloud.Domain.SystemManage;
namespace WaterCloud.Service.SystemManage
{
public class AreaService : BaseService<AreaEntity>, IDenpendency
{
public AreaService(ISqlSugarClient context) : base(context)
{
}
public async Task<List<AreaEntity>> GetList(int layers = 0)
{
var query = repository.IQueryable();
if (layers != 0)
{
query = query.Where(a => a.F_Layers == layers);
}
return await query.Where(a => a.F_DeleteMark == false && a.F_EnabledMark == true).OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task<List<AreaEntity>> GetLookList(int layers = 0)
{
var query = repository.IQueryable().Where(a => a.F_DeleteMark == false && a.F_EnabledMark == true);
if (layers != 0)
{
query = query.Where(a => a.F_Layers == layers);
}
query = GetDataPrivilege("a", "", query);
return await query.OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task<AreaEntity> GetLookForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return GetFieldsFilterData(data);
}
public async Task<AreaEntity> GetForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return data;
}
public async Task DeleteForm(string keyValue)
{
if (await repository.IQueryable(a => a.F_ParentId.Equals(keyValue)).AnyAsync())
{
throw new Exception("删除失败！操作的对象包含了下级数据。");
}
else
{
await repository.Delete(a => a.F_Id == keyValue);
}
}
public async Task SubmitForm(AreaEntity mEntity, string keyValue)
{
if (!string.IsNullOrEmpty(keyValue))
{
mEntity.Modify(keyValue);
await repository.Update(mEntity);
}
else
{
mEntity.F_DeleteMark = false;
mEntity.Create();
await repository.Insert(mEntity);
}
}
}
}

130
WaterCloud.Service/SystemManage/CodegeneratelogService.cs Normal file
View File

@@ -0,0 +1,130 @@
using System;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using WaterCloud.Code;
using SqlSugar;
using WaterCloud.DataBase;
using WaterCloud.Domain.SystemManage;
using WaterCloud.Code.Model;
namespace WaterCloud.Service.SystemManage
{
/// <summary>
/// 创 建：超级管理员
/// 日 期：2022-10-06 14:18
/// 描 述：条码生成记录服务类
/// </summary>
public class CodegeneratelogService : BaseService<CodegeneratelogEntity>, IDenpendency
{
public CodegeneratelogService(ISqlSugarClient context) : base(context)
{
}
#region 获取数据
public async Task<List<CodegeneratelogEntity>> GetList(string keyword = "")
{
var data = repository.IQueryable();
if (!string.IsNullOrEmpty(keyword))
{
data = data.Where(a => a.F_Code.Contains(keyword)
|| a.F_RuleName.Contains(keyword));
}
return await data.Where(a => a.F_DeleteMark == false).OrderBy(a => a.F_Id , OrderByType.Desc).ToListAsync();
}
public async Task<List<CodegeneratelogEntity>> GetLookList(string keyword = "")
{
var query = repository.IQueryable().Where(a => a.F_DeleteMark == false);
if (!string.IsNullOrEmpty(keyword))
{
//此处需修改
query = query.Where(a => a.F_Code.Contains(keyword)
|| a.F_RuleName.Contains(keyword));
}
//权限过滤
query = GetDataPrivilege("a", "", query);
return await query.OrderBy(a => a.F_Id , OrderByType.Desc).ToListAsync();
}
public async Task<List<CodegeneratelogEntity>> GetLookList(SoulPage<CodegeneratelogEntity> pagination,string keyword = "",string id="")
{
var query = repository.IQueryable().Where(a => a.F_DeleteMark == false);
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(a => a.F_Code.Contains(keyword)
|| a.F_RuleName.Contains(keyword));
}
if(!string.IsNullOrEmpty(id))
{
query= query.Where(a=>a.F_Id==id);
}
//权限过滤
query = GetDataPrivilege("a","",query);
return await query.ToPageListAsync(pagination);
}
public async Task<CodegeneratelogEntity> GetForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return data;
}
#endregion
public async Task<CodegeneratelogEntity> GetLookForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return GetFieldsFilterData(data);
}
#region 提交数据
public async Task<List<PrintEntity>> Reprint(string keyValue, int count = 1)
{
var list = new List<PrintEntity>();
var data = await repository.FindEntity(keyValue);
var rule = await repository.Db.Queryable<CoderuleEntity>().FirstAsync(a => a.F_Id == data.F_RuleId);
var template = await repository.Db.Queryable<TemplateEntity>().FirstAsync(a => a.F_Id == rule.F_TemplateId);
if (template.F_Batch == true)
{
PrintEntity entity = new PrintEntity();
entity.data = new PrintDetail();
entity.data.printIniInfo = new PrintInitInfo();
entity.data.printIniInfo.printType = template.F_PrintType;
entity.data.printIniInfo.isBatch = template.F_Batch;
entity.data.printIniInfo.realName = template.F_TemplateName;
entity.data.printIniInfo.filePath = (GlobalContext.HttpContext.Request.IsHttps ? "https://" : "http://") + GlobalContext.HttpContext.Request.Host + template.F_TemplateFile;
entity.requestId = Utils.GetGuid();
var listJson = new List<Dictionary<string, string>>();
for (int i = 0; i < count; i++)
{
listJson.Add(data.F_PrintJson.ToObject<Dictionary<string, string>>());
}
entity.data.data = listJson;
list.Add(entity);
}
else
{
for (int i = 0; i < count; i++)
{
PrintEntity entity = new PrintEntity();
entity.data = new PrintDetail();
entity.data.printIniInfo = new PrintInitInfo();
entity.data.printIniInfo.printType = template.F_PrintType;
entity.data.printIniInfo.isBatch = template.F_Batch;
entity.data.printIniInfo.realName = template.F_TemplateName;
entity.data.printIniInfo.filePath = (GlobalContext.HttpContext.Request.IsHttps ? "https://" : "http://") + GlobalContext.HttpContext.Request.Host + template.F_TemplateFile;
entity.requestId = Utils.GetGuid();
entity.data.data = data.F_PrintJson.ToObject<Dictionary<string, string>>();
list.Add(entity);
}
}
//更新打印次数
await repository.Update(a => a.F_Id == keyValue, a => new CodegeneratelogEntity
{
F_PrintCount = a.F_PrintCount + count
});
return list;
}
#endregion
}
}

492
WaterCloud.Service/SystemManage/CoderuleService.cs Normal file
View File

@@ -0,0 +1,492 @@
using System;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using WaterCloud.Code;
using SqlSugar;
using WaterCloud.DataBase;
using WaterCloud.Domain.SystemManage;
using WaterCloud.Code.Model;
using System.Globalization;
using NetTaste;
namespace WaterCloud.Service.SystemManage
{
/// <summary>
/// 创 建：超级管理员
/// 日 期：2022-10-06 11:25
/// 描 述：条码规则服务类
/// </summary>
public class CoderuleService : BaseService<CoderuleEntity>, IDenpendency
{
public CoderuleService(ISqlSugarClient context) : base(context)
{
}
#region 获取数据
public async Task<List<CoderuleEntity>> GetList(string keyword = "")
{
var data = GetQuery();
if (!string.IsNullOrEmpty(keyword))
{
data = data.Where(a => a.F_RuleName.Contains(keyword));
}
return await data.OrderBy(a => a.F_Id , OrderByType.Desc).ToListAsync();
}
public async Task<List<CoderuleEntity>> GetLookList(string keyword = "")
{
var query = GetQuery();
if (!string.IsNullOrEmpty(keyword))
{
//此处需修改
query = query.Where(a => a.F_RuleName.Contains(keyword));
}
//权限过滤
query = GetDataPrivilege("a", query: query);
return await query.OrderBy(a => a.F_Id , OrderByType.Desc).ToListAsync();
}
public async Task<List<CoderuleEntity>> GetLookList(SoulPage<CoderuleEntity> pagination,string keyword = "",string id="")
{
//反格式化显示只能用"等于"，其他不支持
Dictionary<string, Dictionary<string, string>> dic = new Dictionary<string, Dictionary<string, string>>();
Dictionary<string, string> enabledTemp = new Dictionary<string, string>();
enabledTemp.Add("1", "有效");
enabledTemp.Add("0", "无效");
dic.Add("F_EnabledMark", enabledTemp);
var setList = await GlobalContext.GetService<ItemsDataService>().GetItemList("RuleReset");
Dictionary<string, string> resetTemp = new Dictionary<string, string>();
foreach (var item in setList)
{
resetTemp.Add(item.F_ItemCode, item.F_ItemName);
}
dic.Add("F_Reset", resetTemp);
var printList = await GlobalContext.GetService<ItemsDataService>().GetItemList("PrintType");
Dictionary<string, string> printTemp = new Dictionary<string, string>();
foreach (var item in printList)
{
printTemp.Add(item.F_ItemCode, item.F_ItemName);
}
dic.Add("F_PrintType", printTemp);
pagination = ChangeSoulData(dic, pagination);
var query = GetQuery();
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(a => a.F_RuleName.Contains(keyword));
}
if(!string.IsNullOrEmpty(id))
{
query = query.Where(a => a.F_Id == id);
}
//权限过滤
query = GetDataPrivilege("a", query: query);
return await query.ToPageListAsync(pagination);
}
public async Task<CoderuleEntity> GetForm(string keyValue)
{
var data = await GetQuery().FirstAsync(a => a.F_Id == keyValue);
return data;
}
private ISugarQueryable<CoderuleEntity> GetQuery()
{
var query = repository.IQueryable()
.InnerJoin<TemplateEntity>((a,b)=>a.F_TemplateId == b.F_Id)
.Select((a, b) => new CoderuleEntity
{
F_Id=a.F_Id.SelectAll(),
F_TemplateName = b.F_TemplateName,
F_PrintType = b.F_PrintType,
F_Batch=b.F_Batch
}).MergeTable().Where(a => a.F_DeleteMark == false);
return query;
}
public async Task<CoderuleEntity> GetLookForm(string keyValue)
{
var data = await GetQuery().FirstAsync(a => a.F_Id == keyValue);
return GetFieldsFilterData(data);
}
#endregion
#region 提交数据
public async Task SubmitForm(CoderuleEntity entity, string keyValue)
{
if(string.IsNullOrEmpty(keyValue))
{
entity.F_DeleteMark = false;
entity.Create();
await repository.Insert(entity);
}
else
{
entity.Modify(keyValue);
await repository.Update(entity);
}
}
public async Task DeleteForm(string keyValue)
{
var ids = keyValue.Split(',');
await repository.Delete(a => ids.Contains(a.F_Id.ToString()));
}
/// <summary>
/// 计算编码规则生成流水号<para>注意：此编码规则只支持单个流水号</para>
/// </summary>
/// <param name="ruleName">规则名称</param>
/// <param name="count">生成数量</param>
/// <param name="preview">是否预览,预览不新增条码不操作Redis zincr</param>
/// <param name="replaceList">通配符替换列表</param>
/// <returns></returns>
public async Task<List<string>> GetBillNumber(
string ruleName,
int count,
bool preview = false,
List<string> replaceList = null)
{
var now = DateTime.Now;
var rule = await repository.Db.Queryable<CoderuleEntity>().FirstAsync(a => a.F_RuleName == ruleName);
var resetRule = "NoReset";
switch (rule.F_Reset)
{
//By 年 月 日
case "yyyy":
case "yyyy-MM":
case "yyyy-MM-dd":
resetRule = DateTime.Now.ToString(rule.F_Reset); break;
//By 周
case "yyyy-MM-WW":
var gc = new GregorianCalendar();
var thisWeek = gc.GetWeekOfYear(now, CalendarWeekRule.FirstDay, DayOfWeek.Sunday);
resetRule = DateTime.Now.ToString("yyyy") + "W" + thisWeek; break;
default:
break;
}
var codeRuleFormatList = rule.F_RuleJson.ToObject<List<CodeRuleFormatEntity>>();
//格式化
var format = string.Empty;
var reset = string.Empty;
//流水号长度
int flowNumberLength = 5;
//流水号初始值
int initVal = 0;
//流水号最大值
int? maxVal = null;
//默认10进制
int toBase = 10;
//步长
decimal increment = 1;
string diyCode = string.Empty;
char replaceChar = '*';
List<string> list = new List<string>();
codeRuleFormatList.ForEach(item =>
{
//编码前缀类型 1 - 固定参数 2 - 日期 3 - 年 4 - 月 5 - 日 6 - 周别 7 - 周几 8 - 小时 9 - 上午下午 10 - 班别 11 - 流水号 12 - 自定义
switch (item.FormatType)
{
//固定参数
case 1:
format += item.FormatString;
break;
//日期
case 2:
format += now.ToString(item.FormatString);
break;
//年
case 3:
var ye = now.ToString("yyyy");
//判断是否有自定义
if (!string.IsNullOrEmpty(item.FormatString))
{
var yl = item.FormatString.Length;//yyyy 还是yy 还是y
if (yl <= 4)
ye = ye.Substring(4 - yl, yl);
}
format += ye;
break;
//月
case 4:
var m = item.DiyDate[now.Month - 1];
format += m;
break;
//日
case 5:
var d = item.DiyDate[now.Day - 1];
format += d;
break;
//周别 （本年的第几周）
case 6:
var gc = new GregorianCalendar();
var thisWeek = gc.GetWeekOfYear(now, CalendarWeekRule.FirstDay,DayOfWeek.Sunday);
var y = item.DiyDate[thisWeek - 1];
format += y;
break;
//周几 (按照周一是第一天算)
case 7:
var wk = now.DayOfWeek.ToInt();
if (wk == 0)
wk = 6;
else
wk -= 1;
var w = item.DiyDate[wk];
format += w;
break;
case 8:
var h = now.ToString(item.FormatString);
format += h;
break;
case 9:
var ch = now.Hour;
format += ch < 12? item.DiyDate[0] : item.DiyDate[1];
break;
//班别
case 10:
string csstr = "";
foreach (var cs in item.DiyDate)
{
var strs = cs.Split(".");
var times = strs[1].Split("-");
if (int.Parse(times[0].Split(":")[0]) < int.Parse(times[1].Split(":")[0]))
{
//开始时间
var startTime = DateTime.Parse($"{now:yyyy/MM/dd} {times[0]}");
//结束时间
var endTime = DateTime.Parse($"{now:yyyy/MM/dd} {times[1]}");
if (DateTime.Now>=startTime && DateTime.Now < endTime)
{
csstr = strs[0];
break;
}
}
else
{
//开始时间
var startTime = DateTime.Parse($"{now:yyyy/MM/dd} {times[0]}");
//结束时间
var endTime = DateTime.Parse($"{now:yyyy/MM/dd} {times[1]}").AddDays(1);
if (DateTime.Now >= startTime && DateTime.Now < endTime)
{
csstr = strs[0];
break;
}
}
}
format += csstr;
break;
//流水
case 11:
initVal = item.InitValue.Value;
maxVal = item.MaxValue;
flowNumberLength = item.FormatString.Length;
toBase = item.ToBase;
format += "^_^";
increment = item.Increment.Value;
break;
//自定义方法
case 12:
//反射执行方法获取参数
var udf =((Task<string>)this.GetType().GetMethod(item.FormatString, new Type[] { }).Invoke(this, new object[] { ruleName })).GetAwaiter().GetResult();
format += udf;
break;
//通配符
case 13:
//如果作为检查流水号的长度的条件，则最后一个通配符是00,2位，那么流水号是4位，就会有问题 2 != 4
replaceChar = item.FormatString.FirstOrDefault();
var tempstr = "".PadLeft(item.FormatString.Length, replaceChar);
format += tempstr;
break;
default:
break;
}
});
//判断编码格式是否有效
if (!string.IsNullOrEmpty(format))
{
for (int i = 0; i < count; i++)
{
var score = 0M;
var scoreString = string.Empty;
//预览
if (!preview)
{
if (GlobalContext.SystemConfig.CacheProvider == Define.CACHEPROVIDER_REDIS)
{
score = await BaseHelper.ZIncrByAsync(GlobalContext.SystemConfig.ProjectPrefix + $"_BillNumber:{ruleName}", resetRule, increment);
}
else
{
var rulelog = await repository.Db.Queryable<CoderulelogEntity>().FirstAsync(a => a.F_Key == GlobalContext.SystemConfig.ProjectPrefix + $"_BillNumber:{ruleName}" && a.F_Value == resetRule);
if (rulelog == null)
{
rulelog = new CoderulelogEntity();
rulelog.F_Id = Utils.GetGuid();
rulelog.F_Key = GlobalContext.SystemConfig.ProjectPrefix + $"_BillNumber:{ruleName}";
rulelog.F_Value = resetRule;
rulelog.F_Score = (int)increment;
rulelog.F_RuleId = rule.F_Id;
await repository.Db.Insertable(rulelog).ExecuteCommandAsync();
}
else
{
await repository.Db.Updateable<CoderulelogEntity>(a => new CoderulelogEntity
{
F_Score = a.F_Score + (int)increment
}).Where(a => a.F_Id == rulelog.F_Id).ExecuteCommandAsync();
}
}
}
else
{
if (GlobalContext.SystemConfig.CacheProvider == Define.CACHEPROVIDER_REDIS)
{
score = await BaseHelper.ZScoreAsync(GlobalContext.SystemConfig.ProjectPrefix + $"_BillNumber:{ruleName}", resetRule)??0;
score += increment;
}
else
{
var rulelog = await repository.Db.Queryable<CoderulelogEntity>().FirstAsync(a => a.F_Key == GlobalContext.SystemConfig.ProjectPrefix + $"_BillNumber:{ruleName}" && a.F_Value == resetRule);
if (rulelog == null)
{
score += increment;
}
else
{
score = (rulelog.F_Score??0) + increment;
}
}
}
//10进制流水号
var flowNumber = score + initVal;
//判断流水号是否超过流水号设定的最大值
if (maxVal > 0 && flowNumber > maxVal)
throw new Exception($"Morethan the flownumber settinged max value:{maxVal} and now value:{flowNumber}");
//默认10进制
scoreString = flowNumber.ToString();
if (toBase != 10)
scoreString = scoreString.ToLong().ToBase(toBase);
//^_^是代表可以任意位置流水号
var flow = scoreString.PadLeft(flowNumberLength, '0');
if (flow.Length != flowNumberLength)
{
throw new Exception($"bill encode ({ruleName})settinged error,FlowLength,current:[{flow.Length}],setting:[{flowNumberLength}]");
}
var v = format.Replace("^_^", flow);
if (replaceList!=null&&replaceList.Count>0)
foreach (var item in replaceList)
{
var temp = "".PadLeft(item.Length, replaceChar);
v = v.ReplaceFrist(temp, item);
}
list.Add(v);
}
}
return list;
}
public async Task<Dictionary<string,string>> GetPrintJson(string code,string templateId)
{
var template = await repository.Db.Queryable<TemplateEntity>().FirstAsync(a => a.F_Id == templateId);
List<SugarParameter> list = new List<SugarParameter>();
list.Add(new SugarParameter("rulecode", code));
if (!string.IsNullOrEmpty(template.F_TemplateSqlParm))
{
var dic = template.F_TemplateSqlParm.ToObject<Dictionary<string, object>>();
foreach (var item in dic)
{
list.Add(new SugarParameter(item.Key, item.Value));
}
}
var printResult = string.IsNullOrEmpty(template.F_TemplateSql) ? null : await repository.Db.Ado.SqlQueryAsync<dynamic>(template.F_TemplateSql, list);
if (printResult!=null && printResult.Count>0)
{
var printData = (printResult[0] as IDictionary<string, object>)?.ToDictionary(k => k.Key.ToLower(), v => v.Value?.ToString());
printData.Add("rulecode", code);
return printData;
}
else
{
var printData = new Dictionary<string, string>();
printData.Add("rulecode", code);
return printData;
}
}
public async Task<List<PrintEntity>> CreateForm(string keyValue, int count = 1, bool needPrint = false)
{
var list = new List<PrintEntity>();
var rule = await repository.Db.Queryable<CoderuleEntity>().FirstAsync(a => a.F_Id == keyValue);
var template = await repository.Db.Queryable<TemplateEntity>().FirstAsync(a => a.F_Id == rule.F_TemplateId);
var logs = new List<CodegeneratelogEntity>();
var codes = await GetBillNumber(rule.F_RuleName, count);
if (template.F_Batch == true)
{
PrintEntity entity = new PrintEntity();
entity.data = new PrintDetail();
entity.data.printIniInfo = new PrintInitInfo();
entity.data.printIniInfo.printType = template.F_PrintType;
entity.data.printIniInfo.isBatch = template.F_Batch;
entity.data.printIniInfo.realName = template.F_TemplateName;
entity.data.printIniInfo.filePath = (GlobalContext.HttpContext.Request.IsHttps ? "https://" : "http://") + GlobalContext.HttpContext.Request.Host + template.F_TemplateFile;
entity.requestId = Utils.GetGuid();
var listJson = new List<Dictionary<string, string>>();
for (int i = 0; i < count; i++)
{
var log = new CodegeneratelogEntity();
log.Create();
log.F_Code = codes[i];
log.F_PrintCount = needPrint ? 1 : 0;
log.F_RuleId = rule.F_Id;
log.F_RuleName = rule.F_RuleName;
log.F_EnabledMark = true;
log.F_DeleteMark = false;
var printJson = await GetPrintJson(log.F_Code, template.F_Id);
log.F_PrintJson = printJson.ToJson();
logs.Add(log);
listJson.Add(printJson);
}
entity.data.data = listJson;
list.Add(entity);
}
else
{
for (int i = 0; i < count; i++)
{
var log = new CodegeneratelogEntity();
log.Create();
log.F_Code = codes[i];
log.F_PrintCount = needPrint ? 1 : 0;
log.F_RuleId = rule.F_Id;
log.F_RuleName = rule.F_RuleName;
log.F_EnabledMark = true;
log.F_DeleteMark = false;
var printJson = await GetPrintJson(log.F_Code, template.F_Id);
log.F_PrintJson = printJson.ToJson();
logs.Add(log);
PrintEntity entity = new PrintEntity();
entity.data = new PrintDetail();
entity.data.printIniInfo = new PrintInitInfo();
entity.data.printIniInfo.printType = template.F_PrintType;
entity.data.printIniInfo.isBatch = template.F_Batch;
entity.data.printIniInfo.realName = template.F_TemplateName;
entity.data.printIniInfo.filePath = (GlobalContext.HttpContext.Request.IsHttps ? "https://" : "http://") + GlobalContext.HttpContext.Request.Host + template.F_TemplateFile;
entity.requestId = Utils.GetGuid();
entity.data.data = printJson;
list.Add(entity);
}
}
//新增log
await repository.Db.Insertable(logs).ExecuteCommandAsync();
return list;
}
#endregion
}
}

187
WaterCloud.Service/SystemManage/FlowschemeService.cs Normal file
View File

@@ -0,0 +1,187 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Xml.Linq;
using WaterCloud.Code;
using WaterCloud.DataBase;
using WaterCloud.Domain.FlowManage;
using WaterCloud.Domain.SystemManage;
using WaterCloud.Domain.SystemOrganize;
namespace WaterCloud.Service.SystemManage
{
/// <summary>
/// 创 建：超级管理员
/// 日 期：2020-07-10 08:49
/// 描 述：流程设计服务类
/// </summary>
public class FlowschemeService : BaseService<FlowschemeEntity>, IDenpendency
{
public FlowschemeService(ISqlSugarClient context) : base(context)
{
}
#region 获取数据
public async Task<List<FlowschemeEntity>> GetList(string keyword = "")
{
var query = repository.IQueryable();
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(a => a.F_SchemeCode.Contains(keyword) || a.F_SchemeName.Contains(keyword));
}
var list = currentuser.OrganizeId?.Split(',');
if (list.Any())
{
return await query.Where(a => a.F_DeleteMark == false && (a.F_OrganizeId == "" || a.F_OrganizeId == null || list.Contains(a.F_OrganizeId))).OrderBy(a => a.F_Id, OrderByType.Desc).ToListAsync();
}
return await query.Where(a => a.F_DeleteMark == false && a.F_OrganizeId == "" || a.F_OrganizeId == null).OrderBy(a => a.F_Id, OrderByType.Desc).ToListAsync();
}
public async Task<List<FlowschemeEntity>> GetLookList(string ItemId = "", string keyword = "")
{
var query = repository.IQueryable().Where(a => a.F_DeleteMark == false);
if (!string.IsNullOrEmpty(ItemId))
{
query = query.Where(a => a.F_OrganizeId == ItemId || a.F_OrganizeId == null || a.F_OrganizeId == "");
}
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(a => a.F_SchemeCode.Contains(keyword) || a.F_SchemeName.Contains(keyword));
}
query = GetDataPrivilege("a", "", query);
return await query.OrderBy(a => a.F_CreatorTime, OrderByType.Desc).ToListAsync();
}
public async Task<List<FlowschemeEntity>> GetLookList(Pagination pagination, string keyword = "")
{
var query = repository.IQueryable().Where(a => a.F_DeleteMark == false);
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(a => a.F_SchemeCode.Contains(keyword) || a.F_SchemeName.Contains(keyword));
}
query = GetDataPrivilege("a", "", query);
return await query.ToPageListAsync(pagination);
}
public async Task<FlowschemeEntity> GetForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return data;
}
#endregion 获取数据
public async Task<FlowschemeEntity> GetLookForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return GetFieldsFilterData(data);
}
public async Task<FlowschemeExtend> GetFormExtend(string keyValue)
{
var cachedata = await repository.FindEntity(keyValue);
var temp = cachedata.MapTo<FlowschemeExtend>();
var form = await repository.Db.Queryable<FormEntity>().InSingleAsync(cachedata.F_FrmId);
temp.F_WebId = form.F_WebId;
if (form.F_FrmType == 0)
temp.F_WebId = form.F_DbName;
temp.F_FrmContentData = form.F_ContentData;
temp.F_FrmContent = form.F_Content;
//创建运行实例
var flowinstance = new FlowinstanceEntity();
flowinstance.F_SchemeContent = temp.F_SchemeContent;
var runtime = new FlowRuntime(flowinstance);
if (runtime.nextNodeType != -1 && runtime.nextNode != null && runtime.nextNode.setInfo != null && runtime.nextNodeType != 4)
{
temp.NextNodeDesignateType = runtime.nextNode.setInfo.NodeDesignate;
if (temp.NextNodeDesignateType == Setinfo.SPECIAL_USER)
{
temp.NextNodeDesignates = runtime.nextNode.setInfo.NodeDesignateData.users;
temp.NextMakerName = string.Join(',', repository.Db.Queryable<UserEntity>().Where(a => temp.NextNodeDesignates.Contains(a.F_Id)).Select(a => a.F_RealName).ToList());
}
else if (temp.NextNodeDesignateType == Setinfo.SPECIAL_ROLE)
{
temp.NextNodeDesignates = runtime.nextNode.setInfo.NodeDesignateData.roles;
List<UserEntity> list = new List<UserEntity>();
List<string> users = new List<string>();
foreach (var item in temp.NextNodeDesignates)
{
var usertemp = repository.Db.Queryable<UserEntity>().Where(a => a.F_RoleId.Contains(item)).ToList();
var tempList = new List<UserEntity>();
if (runtime.nextNode.setInfo.NodeDesignateData.currentDepart)
{
var currentDepartment = repository.Db.Queryable<UserEntity>().InSingle(currentuser.UserId).F_OrganizeId.Split(',').ToList();
foreach (var user in usertemp)
{
var nextCurrentDepartment = user.F_OrganizeId.Split(',').ToList();
if (TextHelper.IsArrayIntersection(currentDepartment, nextCurrentDepartment))
{
tempList.Add(user);
}
}
}
else
{
tempList = usertemp;
}
var tempFinal = tempList.Select(a => a.F_Id).ToList();
users.AddRange(tempFinal);
}
users = users.Distinct().ToList();
temp.NextMakerName = string.Join(',', repository.Db.Queryable<UserEntity>().Where(a => users.Contains(a.F_Id)).Select(a => a.F_RealName).ToList());
}
else if (temp.NextNodeDesignateType == Setinfo.DEPARTMENT_MANAGER)//部门负责人
{
var orgs = runtime.nextNode.setInfo.NodeDesignateData.orgs;
if (runtime.nextNode.setInfo.NodeDesignateData.currentDepart)
{
orgs = currentuser.OrganizeId.Split(',');
}
var departments = repository.Db.Queryable<OrganizeEntity>().Where(a => orgs.Contains(a.F_Id) && !string.IsNullOrEmpty(a.F_ManagerId)).Select(a => a.F_ManagerId).ToList();
var departmentNames = repository.Db.Queryable<UserEntity>().Where(a => departments.Contains(a.F_Id)).Select(a => a.F_RealName).ToList();
temp.NextMakerName = string.Join(',', departmentNames);
}
else if (temp.NextNodeDesignateType == Setinfo.USER_MANAGER || temp.NextNodeDesignateType == Setinfo.MORE_USER_MANAGER)//直属上级、直属上级多级负责人
{
var userEntity = repository.Db.Queryable<UserEntity>().InSingle(currentuser.UserId);
if (userEntity != null)
{
var manager = repository.Db.Queryable<UserEntity>().InSingle(userEntity.F_ManagerId);
temp.NextMakerName = manager?.F_RealName;
}
}
}
return temp;
}
#region 提交数据
public async Task SubmitForm(FlowschemeEntity entity, string keyValue)
{
if (string.IsNullOrEmpty(keyValue))
{
//此处需修改
entity.Create();
await repository.Insert(entity);
}
else
{
//此处需修改
entity.Modify(keyValue);
await repository.Update(entity);
}
}
public async Task DeleteForm(string keyValue)
{
var ids = keyValue.Split(',');
await repository.Delete(a => ids.Contains(a.F_Id));
}
#endregion 提交数据
}
}

129
WaterCloud.Service/SystemManage/FormService.cs Normal file
View File

@@ -0,0 +1,129 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using WaterCloud.Code;
using WaterCloud.DataBase;
using WaterCloud.Domain.SystemManage;
using WaterCloud.Domain.SystemOrganize;
namespace WaterCloud.Service.SystemManage
{
/// <summary>
/// 创 建：超级管理员
/// 日 期：2020-07-08 14:33
/// 描 述：表单设计服务类
/// </summary>
public class FormService : BaseService<FormEntity>, IDenpendency
{
public FormService(ISqlSugarClient context) : base(context)
{
}
#region 获取数据
public async Task<List<FormEntity>> GetList(string keyword = "")
{
var query = repository.IQueryable();
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(a => a.F_Name.Contains(keyword) || a.F_Description.Contains(keyword));
}
return await query.Where(a => a.F_DeleteMark == false).OrderBy(a => a.F_Id, OrderByType.Desc).ToListAsync();
}
public async Task<List<FormEntity>> GetLookList(string ItemId = "", string keyword = "")
{
var query = GetQuery().Where(a => a.F_DeleteMark == false);
if (!string.IsNullOrEmpty(ItemId))
{
query = query.Where(a => a.F_OrganizeId == ItemId || a.F_OrganizeId == null || a.F_OrganizeId == "");
}
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(a => a.F_Name.Contains(keyword) || a.F_Description.Contains(keyword));
}
query = GetDataPrivilege("a", "", query);
return await query.Where(a => a.F_DeleteMark == false).OrderBy(a => a.F_Id, OrderByType.Desc).ToListAsync();
}
public async Task<List<FormEntity>> GetLookList(Pagination pagination, string keyword = "")
{
//获取数据权限
var query = GetQuery().Where(a => a.F_DeleteMark == false);
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(a => a.F_Name.Contains(keyword) || a.F_Description.Contains(keyword));
}
query = GetDataPrivilege("a", "", query);
return await query.ToPageListAsync(pagination);
}
private ISugarQueryable<FormEntity> GetQuery()
{
var query = repository.Db.Queryable<FormEntity, OrganizeEntity>((a, b) => new JoinQueryInfos(
JoinType.Left, a.F_OrganizeId == b.F_Id
))
.Select((a, b) => new FormEntity
{
F_Id = a.F_Id.SelectAll(),
F_OrganizeName = b.F_FullName,
}).MergeTable();
return query;
}
public async Task<FormEntity> GetForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return data;
}
public async Task<FormEntity> GetLookForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return GetFieldsFilterData(data);
}
#endregion 获取数据
#region 提交数据
public async Task SubmitForm(FormEntity entity, string keyValue)
{
if (entity.F_FrmType != 1)
{
var temp = FormUtil.SetValue(entity.F_Content);
entity.F_ContentData = string.Join(',', temp.ToArray());
entity.F_Fields = temp.Count();
}
else
{
var temp = FormUtil.SetValueByWeb(entity.F_WebId);
entity.F_ContentData = string.Join(',', temp.ToArray());
entity.F_Fields = temp.Count();
}
if (string.IsNullOrEmpty(keyValue))
{
//此处需修改
entity.F_DeleteMark = false;
entity.Create();
await repository.Insert(entity);
}
else
{
//此处需修改
entity.Modify(keyValue);
await repository.Update(entity);
}
}
public async Task DeleteForm(string keyValue)
{
var ids = keyValue.Split(',');
await repository.Delete(a => ids.Contains(a.F_Id));
}
#endregion 提交数据
}
}

97
WaterCloud.Service/SystemManage/ItemsDataService.cs Normal file
View File

@@ -0,0 +1,97 @@
/*******************************************************************************
* Copyright © 2020 WaterCloud.Framework 版权所有
* Author: WaterCloud
* Description: WaterCloud快速开发平台
* Website：
*********************************************************************************/
using SqlSugar;
using System.Collections.Generic;
using System.Threading.Tasks;
using WaterCloud.Domain.SystemManage;
namespace WaterCloud.Service.SystemManage
{
public class ItemsDataService : BaseService<ItemsDetailEntity>, IDenpendency
{
public ItemsTypeService itemApp { get; set; }
/// <summary>
/// 缓存操作类
/// </summary>
public ItemsDataService(ISqlSugarClient context) : base(context)
{
}
//获取类名
public async Task<List<ItemsDetailEntity>> GetList(string itemId = "", string keyword = "")
{
var list = repository.IQueryable();
if (!string.IsNullOrEmpty(itemId))
{
list = list.Where(a => a.F_ItemId == itemId);
}
if (!string.IsNullOrEmpty(keyword))
{
list = list.Where(a => a.F_ItemName.Contains(keyword) || a.F_ItemCode.Contains(keyword));
}
return await list.Where(a => a.F_DeleteMark == false).OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task<List<ItemsDetailEntity>> GetLookList(string itemId = "", string keyword = "")
{
var query = repository.IQueryable().Where(a => a.F_DeleteMark == false);
if (!string.IsNullOrEmpty(itemId))
{
query = query.Where(a => a.F_ItemId == itemId);
}
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(a => a.F_ItemName.Contains(keyword) || a.F_ItemCode.Contains(keyword));
}
query = GetDataPrivilege("a", "", query);
return await query.OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task<List<ItemsDetailEntity>> GetItemList(string enCode)
{
var itemcachedata = await itemApp.GetList();
var item = itemcachedata.Find(a => a.F_EnCode == enCode);
var data = repository.IQueryable();
return data.Where(a => a.F_DeleteMark == false && a.F_EnabledMark == true && a.F_ItemId == item.F_Id).OrderBy(a => a.F_SortCode).ToList();
}
public async Task<ItemsDetailEntity> GetLookForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return GetFieldsFilterData(data);
}
public async Task<ItemsDetailEntity> GetForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return data;
}
public async Task DeleteForm(string keyValue)
{
await repository.Delete(a => a.F_Id == keyValue);
}
public async Task SubmitForm(ItemsDetailEntity itemsDetailEntity, string keyValue)
{
if (!string.IsNullOrEmpty(keyValue))
{
itemsDetailEntity.Modify(keyValue);
await repository.Update(itemsDetailEntity);
}
else
{
itemsDetailEntity.F_DeleteMark = false;
itemsDetailEntity.Create();
await repository.Insert(itemsDetailEntity);
}
}
}
}

75
WaterCloud.Service/SystemManage/ItemsTypeService.cs Normal file
View File

@@ -0,0 +1,75 @@
/*******************************************************************************
* Copyright © 2020 WaterCloud.Framework 版权所有
* Author: WaterCloud
* Description: WaterCloud快速开发平台
* Website：
*********************************************************************************/
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using WaterCloud.Domain.SystemManage;
namespace WaterCloud.Service.SystemManage
{
public class ItemsTypeService : BaseService<ItemsEntity>, IDenpendency
{
public ItemsTypeService(ISqlSugarClient context) : base(context)
{
}
public async Task<List<ItemsEntity>> GetList()
{
var query = repository.IQueryable();
return await query.Where(a => a.F_DeleteMark == false).OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task<List<ItemsEntity>> GetLookList()
{
var query = repository.IQueryable().Where(a => a.F_DeleteMark == false);
query = GetDataPrivilege("a", "", query);
return await query.OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task<ItemsEntity> GetLookForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return GetFieldsFilterData(data);
}
public async Task<ItemsEntity> GetForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return data;
}
public async Task DeleteForm(string keyValue)
{
if (await repository.IQueryable(a => a.F_ParentId.Equals(keyValue)).AnyAsync())
{
throw new Exception("删除失败！操作的对象包含了下级数据。");
}
else
{
await repository.Delete(a => a.F_Id == keyValue);
}
}
public async Task SubmitForm(ItemsEntity itemsEntity, string keyValue)
{
if (!string.IsNullOrEmpty(keyValue))
{
itemsEntity.Modify(keyValue);
await repository.Update(itemsEntity);
}
else
{
itemsEntity.F_DeleteMark = false;
itemsEntity.F_IsTree = false;
itemsEntity.Create();
await repository.Insert(itemsEntity);
}
}
}
}

172
WaterCloud.Service/SystemManage/ModuleButtonService.cs Normal file
View File

@@ -0,0 +1,172 @@
/*******************************************************************************
* Copyright © 2020 WaterCloud.Framework 版权所有
* Author: WaterCloud
* Description: WaterCloud快速开发平台
* Website：
*********************************************************************************/
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using WaterCloud.Code;
using WaterCloud.Domain.SystemManage;
using WaterCloud.Domain.SystemOrganize;
namespace WaterCloud.Service.SystemManage
{
public class ModuleButtonService : BaseService<ModuleButtonEntity>, IDenpendency
{
private string authorizecacheKey = GlobalContext.SystemConfig.ProjectPrefix + "_authorizeurldata_";// +权限
public ModuleButtonService(ISqlSugarClient context) : base(context)
{
}
public async Task<List<ModuleButtonEntity>> GetList(string moduleId = "")
{
var list = repository.IQueryable();
if (!string.IsNullOrEmpty(moduleId))
{
list = list.Where(a => a.F_ModuleId == moduleId);
}
return await list.Where(a => a.F_DeleteMark == false).OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task<List<ModuleButtonEntity>> GetLookList(string moduleId = "", string keyword = "")
{
var query = repository.IQueryable().Where(a => a.F_DeleteMark == false);
if (!string.IsNullOrEmpty(moduleId))
{
query = query.Where(a => a.F_ModuleId == moduleId);
}
if (!string.IsNullOrEmpty(keyword))
{
//此处需修改
query = query.Where(a => a.F_FullName.Contains(keyword) || a.F_EnCode.Contains(keyword));
}
query = GetDataPrivilege("a", "", query);
return await query.OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task<ModuleButtonEntity> GetLookForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return GetFieldsFilterData(data);
}
public async Task<ModuleButtonEntity> GetForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return data;
}
public async Task DeleteForm(string keyValue)
{
if (await repository.IQueryable(a => a.F_ParentId.Equals(keyValue)).AnyAsync())
{
throw new Exception("删除失败！操作的对象包含了下级数据。");
}
else
{
await repository.Delete(a => a.F_Id == keyValue);
}
await CacheHelper.RemoveAsync(authorizecacheKey + repository.Db.CurrentConnectionConfig.ConfigId + "_list");
}
public async Task<List<ModuleButtonEntity>> GetListByRole(string roleid)
{
var moduleList = repository.Db.Queryable<RoleAuthorizeEntity>().Where(a => a.F_ObjectId == roleid && a.F_ItemType == 2).Select(a => a.F_ItemId).ToList();
var query = repository.IQueryable().Where(a => (moduleList.Contains(a.F_Id) || a.F_IsPublic == true) && a.F_DeleteMark == false && a.F_EnabledMark == true);
return await query.OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task SubmitForm(ModuleButtonEntity moduleButtonEntity, string keyValue)
{
if (!string.IsNullOrEmpty(moduleButtonEntity.F_Authorize))
{
moduleButtonEntity.F_Authorize = moduleButtonEntity.F_Authorize.ToLower();
}
if (!string.IsNullOrEmpty(keyValue))
{
moduleButtonEntity.Modify(keyValue);
await repository.Update(moduleButtonEntity);
}
else
{
moduleButtonEntity.F_DeleteMark = false;
moduleButtonEntity.F_AllowEdit = false;
moduleButtonEntity.F_AllowDelete = false;
var module = await repository.Db.Queryable<ModuleEntity>().Where(a => a.F_Id == moduleButtonEntity.F_ModuleId).FirstAsync();
if (module.F_Target != "iframe" && module.F_Target != "expand")
{
throw new Exception("菜单不能创建按钮");
}
moduleButtonEntity.Create();
await repository.Insert(moduleButtonEntity);
}
await CacheHelper.RemoveAsync(authorizecacheKey + repository.Db.CurrentConnectionConfig.ConfigId + "_list");
}
public async Task SubmitCloneButton(string moduleId, string Ids)
{
string[] ArrayId = Ids.Split(',');
var data = await this.GetList();
List<ModuleButtonEntity> entitys = new List<ModuleButtonEntity>();
var module = await repository.Db.Queryable<ModuleEntity>().Where(a => a.F_Id == moduleId).FirstAsync();
if (module.F_Target != "iframe" && module.F_Target != "expand")
{
throw new Exception("菜单不能创建按钮");
}
foreach (string item in ArrayId)
{
ModuleButtonEntity moduleButtonEntity = data.Find(a => a.F_Id == item);
moduleButtonEntity.Create();
moduleButtonEntity.F_ModuleId = moduleId;
entitys.Add(moduleButtonEntity);
}
await repository.Insert(entitys);
await CacheHelper.RemoveAsync(authorizecacheKey + repository.Db.CurrentConnectionConfig.ConfigId + "_list");
}
public async Task<List<ModuleButtonEntity>> GetListNew(string moduleId = "")
{
var query = repository.Db.Queryable<ModuleButtonEntity, ModuleEntity>((a, b) => new JoinQueryInfos(
JoinType.Inner, a.F_ModuleId == b.F_Id && b.F_EnabledMark == true && b.F_DeleteMark == false
)).Where(a => a.F_EnabledMark == true && a.F_DeleteMark == false)
.Select((a, b) => new ModuleButtonEntity
{
F_Id = a.F_Id,
F_AllowDelete = a.F_AllowDelete,
F_AllowEdit = a.F_AllowEdit,
F_UrlAddress = a.F_UrlAddress,
F_CreatorTime = a.F_CreatorTime,
F_CreatorUserId = a.F_CreatorUserId,
F_DeleteMark = a.F_DeleteMark,
F_DeleteTime = a.F_DeleteTime,
F_DeleteUserId = a.F_DeleteUserId,
F_Description = a.F_Description,
F_EnabledMark = a.F_EnabledMark,
F_EnCode = a.F_EnCode,
F_FullName = a.F_FullName,
F_Icon = a.F_Icon,
F_IsPublic = a.F_IsPublic,
F_JsEvent = a.F_JsEvent,
F_LastModifyTime = a.F_LastModifyTime,
F_LastModifyUserId = a.F_LastModifyUserId,
F_Layers = a.F_Layers,
F_Location = a.F_Location,
F_ModuleId = b.F_UrlAddress,
F_ParentId = a.F_ParentId,
F_SortCode = a.F_SortCode,
F_Split = a.F_Split,
}).MergeTable();
if (!string.IsNullOrEmpty(moduleId))
{
query = query.Where(a => a.F_ModuleId == moduleId);
}
return await query.OrderBy(a => a.F_SortCode).ToListAsync();
}
}
}

142
WaterCloud.Service/SystemManage/ModuleFieldsService.cs Normal file
View File

@@ -0,0 +1,142 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using WaterCloud.Code;
using WaterCloud.DataBase;
using WaterCloud.Domain.SystemManage;
using WaterCloud.Domain.SystemOrganize;
namespace WaterCloud.Service.SystemManage
{
/// <summary>
/// 创 建：超级管理员
/// 日 期：2020-05-21 14:38
/// 描 述：字段管理服务类
/// </summary>
public class ModuleFieldsService : BaseService<ModuleFieldsEntity>, IDenpendency
{
public ModuleFieldsService(ISqlSugarClient context) : base(context)
{
}
#region 获取数据
public async Task<List<ModuleFieldsEntity>> GetList(string keyword = "")
{
var query = repository.IQueryable();
if (!string.IsNullOrEmpty(keyword))
{
//此处需修改
query = query.Where(a => a.F_FullName.Contains(keyword) || a.F_EnCode.Contains(keyword));
}
return await query.Where(a => a.F_DeleteMark == false).OrderBy(a => a.F_Id, OrderByType.Desc).ToListAsync();
}
public async Task<List<ModuleFieldsEntity>> GetLookList(Pagination pagination, string moduleId, string keyword = "")
{
//获取数据权限
var query = repository.IQueryable().Where(a => a.F_DeleteMark == false && a.F_ModuleId == moduleId);
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(a => a.F_FullName.Contains(keyword) || a.F_EnCode.Contains(keyword));
}
query = GetDataPrivilege("a", "", query);
return await query.ToPageListAsync(pagination);
}
public async Task<ModuleFieldsEntity> GetLookForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return GetFieldsFilterData(data);
}
public async Task<ModuleFieldsEntity> GetForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return data;
}
#endregion 获取数据
#region 提交数据
public async Task SubmitForm(ModuleFieldsEntity entity, string keyValue)
{
if (string.IsNullOrEmpty(keyValue))
{
entity.F_DeleteMark = false;
entity.Create();
await repository.Insert(entity);
}
else
{
entity.Modify(keyValue);
await repository.Update(entity);
}
}
public async Task DeleteForm(string keyValue)
{
await repository.Delete(a => a.F_Id == keyValue);
}
public async Task SubmitCloneFields(string moduleId, string ids)
{
string[] ArrayId = ids.Split(',');
var data = await this.GetList();
List<ModuleFieldsEntity> entitys = new List<ModuleFieldsEntity>();
var module = await repository.Db.Queryable<ModuleEntity>().Where(a => a.F_Id == moduleId).FirstAsync();
if (string.IsNullOrEmpty(module.F_UrlAddress) || module.F_Target != "iframe")
{
throw new Exception("框架页才能创建字段");
}
foreach (string item in ArrayId)
{
ModuleFieldsEntity moduleFieldsEntity = data.Find(a => a.F_Id == item);
moduleFieldsEntity.Create();
moduleFieldsEntity.F_ModuleId = moduleId;
entitys.Add(moduleFieldsEntity);
}
await repository.Insert(entitys);
}
public async Task<List<ModuleFieldsEntity>> GetListByRole(string roleid)
{
var moduleList = repository.Db.Queryable<RoleAuthorizeEntity>().Where(a => a.F_ObjectId == roleid && a.F_ItemType == 3).Select(a => a.F_ItemId).ToList();
var query = repository.IQueryable().Where(a => (moduleList.Contains(a.F_Id) || a.F_IsPublic == true) && a.F_DeleteMark == false && a.F_EnabledMark == true);
return await query.OrderBy(a => a.F_CreatorTime, OrderByType.Desc).ToListAsync();
}
internal async Task<List<ModuleFieldsEntity>> GetListNew(string moduleId = "")
{
var query = repository.Db.Queryable<ModuleFieldsEntity, ModuleEntity>((a, b) => new JoinQueryInfos(
JoinType.Inner, a.F_ModuleId == b.F_Id && b.F_EnabledMark == true
))
.Select((a, b) => new ModuleFieldsEntity
{
F_Id = a.F_Id,
F_CreatorTime = a.F_CreatorTime,
F_CreatorUserId = a.F_CreatorUserId,
F_DeleteMark = a.F_DeleteMark,
F_DeleteTime = a.F_DeleteTime,
F_DeleteUserId = a.F_DeleteUserId,
F_Description = a.F_Description,
F_EnabledMark = a.F_EnabledMark,
F_EnCode = a.F_EnCode,
F_FullName = a.F_FullName,
F_LastModifyTime = a.F_LastModifyTime,
F_LastModifyUserId = a.F_LastModifyUserId,
F_ModuleId = b.F_UrlAddress,
F_IsPublic = a.F_IsPublic
}).MergeTable();
if (!string.IsNullOrEmpty(moduleId))
{
query = query.Where(a => a.F_ModuleId == moduleId);
}
return await query.OrderBy(a => a.F_CreatorTime, OrderByType.Desc).ToListAsync();
}
#endregion 提交数据
}
}

135
WaterCloud.Service/SystemManage/ModuleService.cs Normal file
View File

@@ -0,0 +1,135 @@
/*******************************************************************************
* Copyright © 2020 WaterCloud.Framework 版权所有
* Author: WaterCloud
* Description: WaterCloud快速开发平台
* Website：
*********************************************************************************/
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using WaterCloud.Code;
using WaterCloud.Domain.SystemManage;
using WaterCloud.Domain.SystemOrganize;
namespace WaterCloud.Service.SystemManage
{
public class ModuleService : BaseService<ModuleEntity>, IDenpendency
{
/// <summary>
/// 缓存操作类
/// </summary>
private string authorizecacheKey = GlobalContext.SystemConfig.ProjectPrefix + "_authorizeurldata_";// +权限
//获取类名
public ModuleService(ISqlSugarClient context) : base(context)
{
}
public async Task<List<ModuleEntity>> GetList()
{
var query = repository.IQueryable();
return await query.Where(a => a.F_DeleteMark == false).OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task<List<ModuleEntity>> GetBesidesList()
{
var moduleList = repository.Db.Queryable<DataPrivilegeRuleEntity>().Select(a => a.F_ModuleId).ToList();
var query = repository.IQueryable().Where(a => !moduleList.Contains(a.F_Id) && a.F_EnabledMark == true && a.F_Target == "iframe");
return await query.OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task<List<ModuleEntity>> GetLookList()
{
var query = repository.IQueryable().Where(a => a.F_DeleteMark == false);
query = GetDataPrivilege("a", "", query);
return await query.OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task<ModuleEntity> GetLookForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return GetFieldsFilterData(data);
}
public async Task<ModuleEntity> GetForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return data;
}
public async Task<string> GetMaxSortCode(string F_ParentId)
{
try
{
int F_SortCode = (int)await repository.Db.Queryable<ModuleEntity>().Where(t => t.F_ParentId == F_ParentId).MaxAsync(a => a.F_SortCode);
return (F_SortCode + 1).ToString();
}
catch (Exception)
{
return "0";
}
}
public async Task DeleteForm(string keyValue)
{
if (await repository.IQueryable(a => a.F_ParentId.Equals(keyValue)).AnyAsync())
{
throw new Exception("删除失败！操作的对象包含了下级数据。");
}
else
{
repository.Db.Ado.BeginTran();
await repository.Delete(a => a.F_Id == keyValue);
await repository.Db.Deleteable<ModuleButtonEntity>().Where(a => a.F_ModuleId == keyValue).ExecuteCommandAsync();
await repository.Db.Deleteable<ModuleFieldsEntity>().Where(a => a.F_ModuleId == keyValue).ExecuteCommandAsync();
repository.Db.Ado.CommitTran();
await CacheHelper.RemoveAsync(authorizecacheKey + repository.Db.CurrentConnectionConfig.ConfigId + "_list");
}
}
public async Task<List<ModuleEntity>> GetListByRole(string roleid)
{
var moduleList = repository.Db.Queryable<RoleAuthorizeEntity>().Where(a => a.F_ObjectId == roleid && a.F_ItemType == 1).Select(a => a.F_ItemId).ToList();
var query = repository.IQueryable().Where(a => (moduleList.Contains(a.F_Id) || a.F_IsPublic == true) && a.F_DeleteMark == false && a.F_EnabledMark == true);
return await query.OrderBy(a => a.F_SortCode).ToListAsync();
}
public async Task SubmitForm(ModuleEntity moduleEntity, string keyValue)
{
if (!string.IsNullOrEmpty(moduleEntity.F_Authorize))
{
moduleEntity.F_Authorize = moduleEntity.F_Authorize.ToLower();
}
if (!string.IsNullOrEmpty(keyValue))
{
moduleEntity.Modify(keyValue);
await repository.Update(moduleEntity);
}
else
{
moduleEntity.Create();
await repository.Insert(moduleEntity);
}
await CacheHelper.RemoveAsync(authorizecacheKey + repository.Db.CurrentConnectionConfig.ConfigId + "_list");
}
/// <summary>
/// 更新菜单排序
/// </summary>
/// <param name="F_Id">内码</param>
/// <param name="SortCode">排序数字</param>
/// <returns></returns>
public async Task SubmitUpdateForm(string F_Id, int SortCode)
{
//更新
await repository.Update(a => a.F_Id == F_Id, a => new ModuleEntity()
{
F_SortCode = SortCode
});
}
}
}

161
WaterCloud.Service/SystemManage/QuickModuleService.cs Normal file
View File

@@ -0,0 +1,161 @@
//-----------------------------------------------------------------------
// <copyright file=" QuickModule.cs" company="JR">
// * Copyright (C) WaterCloud.Framework All Rights Reserved
// * version : 1.0
// * author : WaterCloud.Framework
// * FileName: QuickModule.cs
// * history : Created by T4 04/13/2020 16:51:13
// </copyright>
//-----------------------------------------------------------------------
using SqlSugar;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using WaterCloud.Code;
using WaterCloud.Domain.SystemManage;
using WaterCloud.Domain.SystemOrganize;
namespace WaterCloud.Service.SystemManage
{
public class QuickModuleService : BaseService<QuickModuleEntity>, IDenpendency
{
public QuickModuleService(ISqlSugarClient context) : base(context)
{
}
public async Task<object> GetTransferList(string userId)
{
var quicklist = repository.IQueryable(a => a.F_CreatorUserId == userId && a.F_EnabledMark == true).ToList();
List<ModuleEntity> quicks = new List<ModuleEntity>();
var user = await repository.Db.Queryable<UserEntity>().InSingleAsync(userId);
var roleId = user.F_RoleId;
if (user.F_IsAdmin == true)
{
roleId = "admin";
}
var rolelist = roleId.Split(',');
var modulelist = repository.Db.Queryable<RoleAuthorizeEntity, ModuleEntity>((a, b) => new JoinQueryInfos(
JoinType.Inner, a.F_ItemId == b.F_Id && b.F_IsMenu == true
)).Where(a => roleId.Contains(a.F_ObjectId) && a.F_ItemType == 1).Select(a => a.F_ItemId).ToList();
if (roleId == "admin")
{
modulelist = repository.Db.Queryable<ModuleEntity>().Where(a => a.F_EnabledMark == true && a.F_IsMenu == true && a.F_DeleteMark == false).Select(a => a.F_Id).ToList();
}
modulelist = modulelist.Distinct().ToList();
quicks = repository.Db.Queryable<ModuleEntity>().Where(a => (modulelist.Contains(a.F_Id) || a.F_IsPublic == true) && a.F_IsMenu == true && a.F_EnabledMark == true && a.F_UrlAddress != null)
.Select(a => new ModuleEntity
{
F_Id = a.F_Id,
F_EnabledMark = false,
F_FullName = a.F_FullName
}).ToList();
foreach (var item in quicklist)
{
var temp = quicks.Find(a => a.F_Id == item.F_ModuleId);
if (temp != null)
{
temp.F_EnabledMark = true;
}
}
return quicks;
}
public async Task<List<QuickModuleExtend>> GetQuickModuleList(string userId)
{
var quicklist = repository.IQueryable(a => a.F_CreatorUserId == userId && a.F_EnabledMark == true);
List<QuickModuleExtend> list = new List<QuickModuleExtend>();
List<QuickModuleEntity> quicks = new List<QuickModuleEntity>();
repository.Db.Ado.BeginTran();
if (!await quicklist.AnyAsync())
{
var user = await repository.Db.Queryable<UserEntity>().InSingleAsync(userId);
var roleId = user.F_RoleId;
if (user.F_IsAdmin == true)
{
roleId = "admin";
}
var rolelist = roleId.Split(',');
var modulelist = repository.Db.Queryable<RoleAuthorizeEntity, ModuleEntity>((a, b) => new JoinQueryInfos(
JoinType.Inner, a.F_ItemId == b.F_Id && b.F_IsMenu == true
)).Where(a => roleId.Contains(a.F_ObjectId) && a.F_ItemType == 1).Select(a => a.F_ItemId).ToList();
if (roleId == "admin")
{
modulelist = repository.Db.Queryable<ModuleEntity>().Where(a => a.F_EnabledMark == true && a.F_IsMenu == true && a.F_DeleteMark == false).Select(a => a.F_Id).ToList();
}
var temp = repository.Db.Queryable<ModuleEntity>().Where(a => a.F_IsPublic == true && a.F_IsMenu == true && a.F_EnabledMark == true && a.F_DeleteMark == false).Select(a => a.F_Id).ToList();
modulelist.AddRange(temp);
modulelist = modulelist.Distinct().ToList();
foreach (var item in modulelist)
{
var module = await repository.Db.Queryable<ModuleEntity>().Where(a => a.F_Id == item && a.F_EnabledMark == true).FirstAsync();
if (module != null && module.F_UrlAddress != null && list.Count < 8)
{
list.Add(new QuickModuleExtend
{
id = module.F_Id,
title = module.F_FullName,
href = module.F_UrlAddress,
icon = module.F_Icon
});
QuickModuleEntity quick = new QuickModuleEntity();
quick.Create();
quick.F_DeleteMark = false;
quick.F_EnabledMark = true;
quick.F_ModuleId = module.F_Id;
quicks.Add(quick);
}
}
}
else
{
foreach (var item in quicklist.ToList())
{
var module = await repository.Db.Queryable<ModuleEntity>().Where(a => a.F_Id == item.F_ModuleId && a.F_EnabledMark == true).FirstAsync();
if (module != null)
{
list.Add(new QuickModuleExtend
{
id = module.F_Id,
title = module.F_FullName,
href = module.F_UrlAddress,
icon = module.F_Icon
});
}
else
{
await repository.Delete(a => a.F_Id == item.F_Id);
}
}
}
if (quicks.Count > 0)
{
await repository.Db.Insertable(quicks).ExecuteCommandAsync();
}
repository.Db.Ado.CommitTran();
return list;
}
public async Task SubmitForm(string[] permissionIds)
{
List<QuickModuleEntity> list = new List<QuickModuleEntity>();
if (permissionIds != null)
{
foreach (var itemId in permissionIds)
{
QuickModuleEntity entity = new QuickModuleEntity();
entity.Create();
entity.F_ModuleId = itemId;
entity.F_EnabledMark = true;
entity.F_DeleteMark = false;
list.Add(entity);
}
}
repository.Db.Ado.BeginTran();
await repository.Delete(a => a.F_CreatorUserId == currentuser.UserId);
await repository.Insert(list);
repository.Db.Ado.CommitTran();
}
}
}

101
WaterCloud.Service/SystemManage/TemplateService.cs Normal file
View File

@@ -0,0 +1,101 @@
using System;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using WaterCloud.Code;
using SqlSugar;
using WaterCloud.DataBase;
using WaterCloud.Domain.SystemManage;
namespace WaterCloud.Service.SystemManage
{
/// <summary>
/// 创 建：超级管理员
/// 日 期：2022-10-06 14:11
/// 描 述：打印模板服务类
/// </summary>
public class TemplateService : BaseService<TemplateEntity>, IDenpendency
{
public TemplateService(ISqlSugarClient context) : base(context)
{
}
#region 获取数据
public async Task<List<TemplateEntity>> GetList(string keyword = "")
{
var data = repository.IQueryable();
if (!string.IsNullOrEmpty(keyword))
{
data = data.Where(a => a.F_TemplateName.Contains(keyword));
}
return await data.Where(a => a.F_DeleteMark == false).OrderBy(a => a.F_Id , OrderByType.Desc).ToListAsync();
}
public async Task<List<TemplateEntity>> GetLookList(string keyword = "")
{
var query = repository.IQueryable().Where(a => a.F_DeleteMark == false);
if (!string.IsNullOrEmpty(keyword))
{
//此处需修改
query = query.Where(a => a.F_TemplateName.Contains(keyword));
}
//权限过滤
query = GetDataPrivilege("a", "", query);
return await query.OrderBy(a => a.F_Id , OrderByType.Desc).ToListAsync();
}
public async Task<List<TemplateEntity>> GetLookList(SoulPage<TemplateEntity> pagination,string keyword = "",string id="")
{
var query = repository.IQueryable().Where(a => a.F_DeleteMark == false);
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(a => a.F_TemplateName.Contains(keyword));
}
if(!string.IsNullOrEmpty(id))
{
query= query.Where(a=>a.F_Id==id);
}
//权限过滤
query = GetDataPrivilege("a","",query);
return await query.ToPageListAsync(pagination);
}
public async Task<TemplateEntity> GetForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return data;
}
#endregion
public async Task<TemplateEntity> GetLookForm(string keyValue)
{
var data = await repository.FindEntity(keyValue);
return GetFieldsFilterData(data);
}
#region 提交数据
public async Task SubmitForm(TemplateEntity entity, string keyValue)
{
if(string.IsNullOrEmpty(keyValue))
{
//初始值添加
entity.F_DeleteMark = false;
entity.Create();
await repository.Insert(entity);
}
else
{
//此处需修改
entity.Modify(keyValue);
await repository.Update(entity);
}
}
public async Task DeleteForm(string keyValue)
{
var ids = keyValue.Split(',');
await repository.Delete(a => ids.Contains(a.F_Id.ToString()));
}
#endregion
}
}