/// <summary>
/// 修改题库的题
/// </summary>
/// <param name="questionBank"></param>
/// <returns></returns>
public int Update(QuestionBankinherit questionBankinherit)
{
SqlSugarClient sugarClient = Educationcontext.GetClient();
//修改题库
QuestionBank questionBank = new QuestionBank();
questionBank.Subject = questionBankinherit.Subject;
questionBank.Answer = questionBankinherit.Answer;
questionBank.Photo = questionBankinherit.Photo;
questionBank.TypeOfExam = questionBankinherit.TypeOfExam;
questionBank.Enable = questionBankinherit.Enable;
questionBank.Id = questionBankinherit.Id;
var questionBankId = questionBankinherit.Id;
var resultquestionBank = sugarClient.Updateable <QuestionBank>(questionBank).ExecuteCommand();
if (resultquestionBank != 0)
{
//修改选项
Option option = sugarClient.SqlQueryable <Option>("select * from `Option` where QuestionBankId = " + questionBankinherit.Id).First();
option.AnswerA = questionBankinherit.AnswerA;
option.AnswerB = questionBankinherit.AnswerB;
option.AnswerC = questionBankinherit.AnswerC;
option.AnswerD = questionBankinherit.AnswerD;
option.AnswerE = questionBankinherit.AnswerE;
var resultoption = sugarClient.Updateable <Option>(option).ExecuteCommand();
if (resultoption != 0)
{
return(1);
}
}
return(0);
}
public DbResult <bool> Auditin(long userId, long stockOutId)
{
var flag = _client.Ado.UseTran(() =>
{
//添加库存 如果有则修改 如果没有新增 添加库存明细
var stockOutDetailList = _client.Queryable <Wms_stockoutdetail>().Where(c => c.StockOutId == stockOutId).ToList();
var inventory = new Wms_inventory();
stockOutDetailList.ForEach(c =>
{
var exist = _client.Queryable <Wms_inventory>().Where(i => i.MaterialId == c.MaterialId && i.StoragerackId == c.StoragerackId).First();
CheckNull.ArgumentIsNullException(exist, PubConst.StockOut1);
if (exist.Qty < c.ActOutQty)
{
CheckNull.ArgumentIsNullException(PubConst.StockOut2);
}
//update
exist.Qty = exist.Qty - c.ActOutQty;
exist.ModifiedBy = userId;
exist.ModifiedDate = DateTimeExt.DateTime;
_client.Updateable(exist);
});
//修改明细状态 2
_client.Updateable(new Wms_stockoutdetail {
Status = StockInStatus.egis.ToByte(), AuditinId = userId, AuditinTime = DateTimeExt.DateTime, ModifiedBy = userId, ModifiedDate = DateTimeExt.DateTime
}).UpdateColumns(c => new { c.Status, c.AuditinId, c.AuditinTime, c.ModifiedBy, c.ModifiedDate }).Where(c => c.StockOutId == stockOutId && c.IsDel == 1).ExecuteCommand();
//修改主表中的状态改为进行中 2
_client.Updateable(new Wms_stockout {
StockOutId = stockOutId, StockOutStatus = StockInStatus.egis.ToByte(), ModifiedBy = userId, ModifiedDate = DateTimeExt.DateTime
}).UpdateColumns(c => new { c.StockOutStatus, c.ModifiedBy, c.ModifiedDate }).ExecuteCommand();
});
return(flag);
}
/// <summary>
/// 设置成员SL
/// 同时自动下树
/// 如果只清空则不会修改状态
/// </summary>
/// <param name="uid">成员UID</param>
/// <param name="cleanSL">是否清空SL</param>
/// <returns>
/// <para><see langword="true"/> 写入成功</para>
/// <para><see langword="false"/> 数据库错误</para>
/// </returns>
public bool SetMemberSL(long uid, bool cleanSL = false)
{
try
{
using SqlSugarClient dbClient = SugarUtils.CreateSqlSugarClient(DBPath);
if (cleanSL) //清空SL
{
return(dbClient
.Updateable(new MemberInfo
{
SL = 0
})
.UpdateColumns(i => new { i.SL })
.Where(i => i.Gid == GuildEventArgs.SourceGroup.Id && i.Uid == uid)
.ExecuteCommandHasChange());
}
else //设置新的SL
{
return(dbClient
.Updateable(new MemberInfo
{
Flag = FlagType.IDLE, SL = Utils.GetNowTimeStamp(), Time = Utils.GetNowTimeStamp(), Info = null
})
.UpdateColumns(i => new { i.Flag, i.SL, i.Time, i.Info })
.Where(i => i.Gid == GuildEventArgs.SourceGroup.Id && i.Uid == uid)
.ExecuteCommandHasChange());
}
}
catch (Exception e)
{
ConsoleLog.Error("Database error", ConsoleLog.ErrorLogBuilder(e));
return(false);
}
}
/// <summary>
/// 保存登录名和密码
/// </summary>
/// <param name="device"></param>
/// <returns></returns>
int IDeviceListDAL.InsertDNameDPwd(DeviceList device)
{
return(db.Updateable <DeviceList>(it => new DeviceList()
{
duname = device.duname, dpwd = device.dpwd
}).Where(it => it.did == device.did).ExecuteCommand());
}
/// <summary>
/// 设置用户信息
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <SetUserOutput> SetUser(SetUserInput input)
{
var model = _mapper.Map <SetUserInput, UserInfo>(input);
if (model.Id > 0)
{
model.UpdateTime = DateTime.Now;
if (!model.Password.IsEmpty())
{
model.Salt = Randoms.CreateRandomValue(8, false);
model.Password = Encrypt.SHA256(model.Password + model.Salt);
// 基础字段不容许更新
await _dbContext.Updateable(model)
.IgnoreColumns(it => new { it.UserName, it.Mobile, it.CreateTime })
.ExecuteCommandAsync();
}
else
{
// 基础字段不容许更新
await _dbContext.Updateable(model)
.IgnoreColumns(it => new { it.UserName, it.Password, it.Salt, it.Mobile, it.CreateTime })
.ExecuteCommandAsync();
}
}
else
{
model.CreateTime = DateTime.Now;
model.UpdateTime = DateTime.Now;
model.Salt = Randoms.CreateRandomValue(8, false);
model.Password = Encrypt.SHA256(model.Password + model.Salt);
model.Id = Convert.ToInt64($"{Time.GetUnixTimestamp()}{ Randoms.CreateRandomValue(3, true) }");
await _dbContext.Insertable(model).ExecuteCommandAsync();
}
// 用户角色操作
List <UserRoleInfo> userRoleList = new List <UserRoleInfo>();
foreach (var id in input.RoleIdList)
{
// 防止重复数据
if (!userRoleList.Exists(it => it.RoleId == id))
{
userRoleList.Add(new UserRoleInfo
{
Uid = model.Id,
RoleId = id
});
}
}
// 删除用户当前角色
await _dbContext.Deleteable <UserRoleInfo>().Where(f => f.Uid == model.Id).ExecuteCommandAsync();
// 添加用户角色
if (userRoleList.Count > 0)
{
await _dbContext.Insertable(userRoleList).ExecuteCommandAsync();
}
return(new SetUserOutput {
});
}
private void btnSave1_Click(object sender, EventArgs e)
{
if (this.txtName.txt.Text == "")
{
int num1 = (int)MessageBox.Show(this, "请输入机器名称!!!", "提示");
}
else
{
try
{
var list = db.Queryable <T_Base>()
.Where(a => a.leibie == clset && a.bianhao == txtJH.coboEX1.Text)
.ToList();
if (list.Count > 0)
{
var asd = list[0];
asd.itemName = txtName.txt.Text;
db.Updateable(asd).ExecuteCommand();
int num2 = (int)MessageBox.Show(this, "基本信息保存成功!!!", "提示");
}
}
catch (Exception ex)
{
int num2 = (int)MessageBox.Show(this, ex.Message, "提示");
}
}
}
/// <summary>
/// 更新实体数据
/// </summary>
/// <param name="entity">博文实体类</param>
/// <returns></returns>
public bool Update(TEntity entity)
{
//这种方式会以主键为条件
var i = db.Updateable(entity).ExecuteCommand();
return(i > 0);
}
/// <summary>
/// 设置壁纸为已下载
/// </summary>
/// <param name="fullName"></param>
/// <param name="info"></param>
/// <returns></returns>
public static bool SetDown(string fullName, ImgInfo info)
{
try
{
Download down = db.Queryable <Download>().Where(o => o.PictureId == info.Id).First();
if (down == null)
{
Picture picModel = db.Queryable <Picture>().Where(o => o.Id == info.Id).First();
if (picModel == null)
{
picModel = ToPicture(info);
db.Insertable(picModel).ExecuteCommand();
}
down = new Download()
{
PictureId = info.Id, Time = DateTime.Now, FullName = fullName, Valid = 1
};
db.Insertable(down).ExecuteCommand();
}
else
{
down.Valid = 1;
down.FullName = fullName;
db.Updateable(down).UpdateColumns(it => new { it.Valid, it.FullName }).ExecuteCommand();
}
return(true);
}
catch (Exception ex)
{
LogHelper.WriteLog(ex.Message, EnumLogLevel.Error);
return(false);
}
}
/// <summary>
/// 更新实体数据
/// </summary>
/// <param name="entity">博文实体类</param>
/// <returns></returns>
public async Task <bool> Update(TEntity entity)
{
//这种方式会以主键为条件
var i = await Task.Run(() => db.Updateable(entity).ExecuteCommand());
return(i > 0);
}
/// <summary>
/// 更新实体数据
/// </summary>
/// <param name="entity">博文实体类</param>
/// <returns></returns>
public async Task <bool> Update(TEntity entity)
{
//这种方式会以主键为条件
var i = await db.Updateable(entity).ExecuteCommandAsync();
return(i > 0);
}
private void button1_Click(object sender, EventArgs e)
{
SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = "server=localhost;uid=root;pwd=12345;database=db",
DbType = SqlSugar.DbType.MySql, //设置数据库类型
IsAutoCloseConnection = true, //自动释放数据务，如果存在事务，在事务结束后释放
InitKeyType = InitKeyType.Attribute //从实体特性中读取主键自增列信息
});
var result = db.Updateable <merchants>().SetColumns(it => it.m_catalog == comboBox1.SelectedItem)
.Where(it => it.m_id == current_id)
.ExecuteCommand();
var result1 = db.Updateable <merchants>().SetColumns(it => it.m_name == textBox1.Text)
.Where(it => it.m_id == current_id)
.ExecuteCommand();
var result2 = db.Updateable <merchants>().SetColumns(it => it.m_address == textBox2.Text)
.Where(it => it.m_id == current_id)
.ExecuteCommand();
var result3 = db.Updateable <merchants>().SetColumns(it => it.m_describe == textBox3.Text)
.Where(it => it.m_id == current_id)
.ExecuteCommand();
this.Hide();
Merchant_sys merchant = new Merchant_sys(login_window, current_id);
merchant.Show();
this.Hide();
}
//删除部门
public string DeparmentISDel(int id)
{
int count = 0;
Department a = db.Queryable <Department>().First(r => r.DepartmentID == id);
try
{
db.Ado.BeginTran();
if (id == 1 || id == 2 || id == 3 || id == 4 || id == 5 || id == 6)
{
return("基础部门不能删除");
}
else
{
if (a != null)
{
//把部门是否删除设置为1
a.isDel = 1;
count += db.Updateable(a).ExecuteCommand();
if (count > 0)
{
//查询当前部门的员工
var list = db.Queryable <UserInfo>().Where(r => r.DepartmentID == id).ToList();
if (list != null)
{
//把当前部门的员工全部放到临时部
foreach (var item in list)
{
item.DepartmentID = 4;
}
count += db.Updateable(list).ExecuteCommand();
}
db.Ado.CommitTran();
if (count >= list.Count() + 1)
{
return("ok");
}
else
{
return("成功但失败,员工未转移至临时部门");
}
}
else
{
return("no");
}
}
else
{
return("未找到此部门");
}
}
}
catch (Exception e)
{
db.Ado.RollbackTran();
return("错误信息:" + e.Message);
}
}
/// <summary>
/// 修改信息.
/// </summary>
/// <param name="id">用户id.</param>
/// <param name="password">用户新密码.</param>
/// <returns>Json.</returns>
public ActionResult EditUserPassword(int id, string password)
{
var user = Db.Queryable <User>().Where(it => it.Id == id).Single();
user.Password = password;
Db.Updateable(user).ExecuteCommand();
return(Json(new { code = 200 }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 更新实体数据
/// </summary>
/// <param name="model">实体类</param>
/// <returns></returns>
public async Task <bool> Update(TEntity model)
{
//throw new NotImplementedException();
//这种方式以主键为条件
var i = await Task.Run(() => db.Updateable(model).ExecuteCommand());
return(i > 0);
}
/// <summary>
/// 修改信息.
/// </summary>
/// <param name="id">用户id.</param>
/// <param name="name">用户新昵称.</param>
/// <returns>Json.</returns>
public ActionResult EditInfo(int id, string name)
{
var user = Db.Queryable <User>().Where(it => it.Id == id).Single();
user.Name = name;
Db.Updateable(user).ExecuteCommand();
return(Json(new { code = 200 }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 更新实体数据
/// </summary>
/// <param name="entity">博文实体类</param>
/// <returns></returns>
public async Task <bool> Update(TEntity entity)
{
////这种方式会以主键为条件
//var i = await Task.Run(() => _db.Updateable(entity).ExecuteCommand());
//return i > 0;
//这种方式会以主键为条件
return(await _db.Updateable(entity).ExecuteCommandHasChangeAsync());
}
/// <summary>
/// 置顶文章.
/// </summary>
/// <param name="articleId">文章编号.</param>
/// <returns>Json.</returns>
public ActionResult TopArticle(int articleId)
{
var article = Db.Queryable <Article>().Where(it => it.Id == articleId).Single();
article.IsTop = 1;
Db.Updateable(article).ExecuteCommand();
return(Json(new { code = 200 }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 修改操作
/// </summary>
/// <param name="db"></param>
/// <param name="model"></param>
/// <param name="adminUser"></param>
/// <returns></returns>
public ResultJson Change(SqlSugarClient db, sysmenu model, string adminUser)
{
var json = new ResultJson()
{
backurl = "close", msg = "保存成功~"
};
model.UpdateDate = DateTime.Now;
model.SysID = 1;
if (model.ID == 0)
{
var tempM = db.Insertable(model).ExecuteReutrnIdentity();
if (model.ParentId > 0)
{
//说明有父级 根据父级，查询对应的模型
var parModel = db.Queryable <sysmenu>().InSingle(model.ParentId);
if (parModel != null)
{
model.ClassList = parModel.ClassList + Convert.ToInt32(tempM) + ",";
model.ClassLayer = parModel.ClassLayer + 1;
model.ID = Convert.ToInt32(tempM);
}
}
else
{
//没有父级
model.ClassList = "," + Convert.ToInt32(tempM) + ",";
}
db.Updateable(model).ExecuteCommand();
}
else
{
//判断修改之前的父级栏目是否和当前的相当
if (FytRequest.GetFormInt("SouParentId") != model.ParentId)
{
//不相等更改等级
var parModel = db.Queryable <sysmenu>().InSingle(model.ParentId);
if (parModel != null)
{
model.ClassList = parModel.ClassList + model.ID + ",";
model.ClassLayer = parModel.ClassLayer + 1;
}
}
db.Updateable(model).ExecuteCommand();
}
db.Insertable(new syslog()
{
UserName = adminUser,
Title = "修改菜单：" + model.Name,
IP = FytRequest.GetIp(),
LogType = 6,
LogGrade = "1",
RequestUrl = FytRequest.GetUrl(),
AddDate = DateTime.Now
}).ExecuteCommand();
return(json);
}
/// <summary>
/// 根据用户名更新数据
/// </summary>
/// <param name="userList"></param>
/// <returns></returns>
int IUserListDAL.UpdataByUName(UserList userList)
{
int result = db.Updateable <UserList>(it => new UserList()
{
upermission = userList.upermission, uisAlive = userList.uisAlive
}).Where(it => it.uname == userList.uname).ExecuteCommand();
return(result);
}
public bool Auditin(long UserId, long stockInId)
{
var flag = _client.Ado.UseTran(() =>
{
//添加库存 如果有则修改 如果没有新增 添加库存明细
var stockInDetailList = _client.Queryable <Wms_stockindetail>().Where(c => c.StockInId == stockInId).ToList();
var inventoryListAdd = new List <Wms_inventory>();
var inventoryListUpdate = new List <Wms_inventory>();
var inventoryDetail = new List <Wms_inventoryrecord>();
var inventory = new Wms_inventory();
stockInDetailList.ForEach(c =>
{
var exist = _client.Queryable <Wms_inventory>().Where(i => i.MaterialId == c.MaterialId && i.StoragerackId == c.StoragerackId).First();
if (exist.IsNullT())
{
//add
inventory.InventoryId = PubId.SnowflakeId;
inventory.StoragerackId = c.StoragerackId;
inventory.CreateBy = UserId;
inventory.Qty = c.ActInQty;
inventory.MaterialId = c.MaterialId;
//inventoryListAdd.Add(exist);
_client.Insertable(inventory).ExecuteCommand();
}
else
{
//update
exist.Qty = exist.Qty + c.ActInQty;
exist.ModifiedBy = UserId;
exist.ModifiedDate = DateTimeExt.DateTime;
//inventoryListUpdate.Add(exist);
_client.Updateable(exist).ExecuteCommand();
}
inventoryDetail.Add(new Wms_inventoryrecord
{
InventoryrecordId = PubId.SnowflakeId,
CreateBy = UserId,
Qty = c.ActInQty,
StockInDetailId = c.StockInDetailId,
});
});
//_inventory.Insert(inventoryListAdd);
//_inventory.Update(inventoryListUpdate);
_client.Insertable(inventoryDetail).ExecuteCommand();
//修改明细状态 2
_client.Updateable(new Wms_stockindetail {
Status = StockInStatus.egis.ToByte(), AuditinId = UserId, AuditinTime = DateTimeExt.DateTime, ModifiedBy = UserId, ModifiedDate = DateTimeExt.DateTime
}).UpdateColumns(c => new { c.Status, c.AuditinId, c.AuditinTime, c.ModifiedBy, c.ModifiedDate })
.Where(c => c.StockInId == stockInId && c.IsDel == 1).ExecuteCommand();
//修改主表中的状态改为进行中 2
_client.Updateable(new Wms_stockin {
StockInId = stockInId, StockInStatus = StockInStatus.egis.ToByte(), ModifiedBy = UserId, ModifiedDate = DateTimeExt.DateTime
}).UpdateColumns(c => new { c.StockInStatus, c.ModifiedBy, c.ModifiedDate }).ExecuteCommand();
}).IsSuccess;
return(flag);
}
/// <summary>
/// 新建报修.
/// </summary>
/// /// <param name="order">传入数据.</param>
/// <returns>Json.</returns>
public ActionResult AddRepair(RepairOrder order)
{
// 自增列用法
int orderId = Db.Insertable(order).ExecuteReturnIdentity();
order.Id = orderId;
order.CreateTime = DateTime.Now.ToString();
Db.Updateable(order).ExecuteCommand();
return(Json(new { code = 200 }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 进入歌内容界面.
/// </summary>
/// <returns>歌内容界面.</returns>
public ActionResult SongContent(int songId, int userId)
{
var song = Db.Queryable <Song>().Where(it => it.Id == songId).Single();
song.Times += 1;
Db.Updateable(song).ExecuteCommand();
ViewBag.UserId = userId;
ViewBag.SongId = songId;
return(View());
}
/// <summary>
/// update Status = Model.Enum.Status.删除
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public virtual bool Delete(int id)
{
var r = SqlSugarClient.Updateable <T>().UpdateColumns(it => new T()
{
Status = Model.Enum.Status.除
})
.Where(it => it.Id == id).ExecuteCommand();
return(r > 0);
}
/// <summary>
/// 逻辑删除(状态修改为删除)
/// </summary>
/// <typeparam name="T">表实体</typeparam>
/// <param name="entity">实体内容</param>
/// <param name="fields">要修改的字段</param>
/// <param name="where">修改条件</param>
/// <returns>受影响行数</returns>
public int Delete <T>(T entity, Expression <Func <T, object> > fields, Expression <Func <T, bool> > where = null) where T : class, new()
{
var upd = _db.Updateable(entity).UpdateColumns(fields);
if (where != null)
{
upd.Where(where);
}
return(upd.ExecuteCommand());
}
/// <summary>
/// 派遣维修单.
/// </summary>
/// <param name="manInform">维修人员信息.</param>
/// <param name="orderId">维修单编号.</param>
/// <returns>JSON.</returns>
public ActionResult SendOrder(string manInform, int orderId)
{
string[] inform = manInform.Split(' ');
int manId = int.Parse(inform[0]);
var order = Db.Queryable <RepairOrder>().Where(it => it.Id == orderId).Single();
order.MaintainerId = manId;
order.Status = "进行中";
Db.Updateable(order).ExecuteCommand();
return(Json(new { code = 200 }, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> PreviewPage(Guid Id)
{
ViewData["Id"] = Id.ToString();
var projectModel = await dbClient.Queryable <Project>().FirstAsync(x => x.Id == Id);
ViewData["ProjectData"] = projectModel;
projectModel.Views += 1;
await dbClient.Updateable(projectModel).ExecuteCommandAsync();
return(View());
}
/// <summary>
/// 数据清洗
/// </summary>
/// <param name="db">dbClient</param>
/// <param name="listModalityDate">检查类型对应排班日期段列表</param>
private List <ModalityArrangeDate> ClearData(SqlSugarClient db, List <ModalityArrangeDate> listModalityDate)
{
var returnList = new List <ModalityArrangeDate>();
try
{
db.BeginTran();
listModalityDate.ForEach(item =>
{
var newInfoList = new List <t_mt_queuearrangemain>();
List <String> deleteList = new List <string>();
item.ArrangeDateList.ForEach(ele =>
{
//当前时间和结束之间差值
var dateDistance = CommonHandleMethod.DateDiff(DateTime.Now.ToDate1().ToDateTime(), ele.QueueArrangeEndDate.ToDateTime());
if (dateDistance > 0)
{
if (!deleteList.Contains(ele.ModalityID))
{
deleteList.Add(ele.ModalityID);
}
ele.AlterDT = DateTime.Now.ToDate4();
ele.IsDelete = 1;
db.Updateable <t_mt_queuearrangemain>(ele).ExecuteCommand();
}
else
{
newInfoList.Add(ele);
}
});
newInfoList.ForEach(element =>
{
if (element.SequenceNumber > 1 && deleteList.Contains(element.ModalityID))
{
element.SequenceNumber = element.SequenceNumber - 1;
db.Updateable <t_mt_queuearrangemain>(element).ExecuteCommand();
}
});
returnList.Add(new ModalityArrangeDate
{
ModalityId = item.ModalityId,
Modality = item.Modality,
ArrangeDateList = newInfoList
});
});
return(returnList);
}
catch (Exception ex)
{
throw (ex);
}
}
/// <summary>
/// 修改
/// </summary>
/// <param name="entity">实例对象</param>
/// <param name="ignoreColumns">排除列</param>
/// <param name="isLock">是否加锁</param>
/// <returns>执行结果</returns>
public bool Update(T entity, List <string> ignoreColumns = null, bool isLock = false)
{
if (ignoreColumns == null)
{
ignoreColumns = new List <string>();
}
var result = isLock ?
db.Updateable(entity).With(SqlWith.UpdLock).IgnoreColumns(ignoreColumns.ToArray()).ExecuteCommand()
: db.Updateable(entity).IgnoreColumns(ignoreColumns.ToArray()).ExecuteCommand();
return(result > 0);
}
public virtual bool Edit <T>(T t, Expression <Func <T, bool> > UpdateExpression, Expression <Func <T, bool> > WhereExpression) where T : class, new()
{
string[] _ignoreUpdateProperties = typeof(T).GetProperties().Where(o => o.GetCustomAttribute(typeof(IgnoreUpdateAttribute)) != null).Select(o => o.Name).ToArray();
var up = db.Updateable <T>(t).SetColumnsIF(UpdateExpression != null, UpdateExpression)
.Where(WhereExpression);
if (_ignoreUpdateProperties.Any())
{
up.IgnoreColumns(_ignoreUpdateProperties);
}
return(up.ExecuteCommand() > 0);
}
private Task RunTaskAsyncEx(SqlSugarClient db, DmeModel model, DmeModelVersion modelVersion, DmeTask task, IList <DmeRuleStep> ruleSteps)
{
return(Task.Run(() =>
{
return db.Ado.UseTran <DmeTask>(() =>
{
try
{
// 查询步骤前后依赖关系
// 形成链表
IList <DmeRuleStepHop> hops = db.Queryable <DmeRuleStepHop>().Where(rsh => rsh.ModelId == model.Id && rsh.VersionId == modelVersion.Id).OrderBy("STEP_FROM_ID").ToList();
IList <RuleStepLinkedListNode <DmeRuleStep> > rulestepLinkedList = this.GetRuleStepNodeLinkedList(db, model, modelVersion, ruleSteps);
foreach (var item in rulestepLinkedList)
{
// 开始计算步骤
this.RunRuleStepNode(db, task, item);
}
// 完成模型计算
task.Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_SUCCESS);
task.LastTime = DateUtil.CurrentTimeMillis;
db.Updateable <DmeTask>(task).ExecuteCommand();
// @TODO 发送模型计算成功的消息
KafkaProducer.Send(nameof(EnumMessageType.TASK), new MessageBody()
{
// 创建者一致
From = "123",
To = "123",
ChannelType = EnumChannelType.P2P,
MessageType = EnumMessageType.TASK,
Payload = $"模型[{task.SysCode}]计算完成，状态[{task.Status}]"
});
return task;
}
catch (Exception ex)
{
// 更改任务执行的状态
if (ex is BusinessException)
{
task.Status = EnumUtil.GetEnumDisplayName(EnumUtil.GetEnumObjByValue <EnumSystemStatusCode>(((BusinessException)ex).Code));
}
else
{
task.Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_ERROR);
}
task.LastTime = DateUtil.CurrentTimeMillis;
db.Updateable <DmeTask>(task).ExecuteCommand();
// 添加日志
this.LogService.AddLogAsync(Base.Common.Log.EnumLogType.ENTITY, Base.Common.Log.EnumLogLevel.ERROR, nameof(DmeTask), task.SysCode, "", ex, "", NetAssist.GetLocalHost());
throw ex;
}
});
}));
}
