/// <summary>
/// 根据主键删除，并返回操作是否成功
/// </summary>
/// <typeparam name="S">主键的类型</typeparam>
/// <param name="key">主键</param>
/// <returns></returns>
public async Task <bool> Delete <S>(S key)
{
return(await _dbBase.Deleteable <T>().In(key).ExecuteCommandAsync() > 0);
}
/// <summary>
/// 根据实体删除一条数据
/// </summary>
/// <param name="entity">博文实体类</param>
/// <returns></returns>
public async Task <bool> Delete(TEntity entity)
{
//var i = await Task.Run(() => _db.Deleteable(entity).ExecuteCommand());
//return i > 0;
return(await _db.Deleteable(entity).ExecuteCommandHasChangeAsync());
}
private static void DistributedTransactionExample()
{
Console.WriteLine("");
Console.WriteLine("#### Distributed TransactionExample Start ####");
SqlSugarClient db = new SqlSugarClient(new List <ConnectionConfig>()
{
new ConnectionConfig()
{
ConfigId = "1", DbType = DbType.Sqlite, ConnectionString = Config.ConnectionString, InitKeyType = InitKeyType.Attribute, IsAutoCloseConnection = true
},
new ConnectionConfig()
{
ConfigId = "2", DbType = DbType.Sqlite, ConnectionString = Config.ConnectionString2, InitKeyType = InitKeyType.Attribute, IsAutoCloseConnection = true
}
});
//use db1
db.CodeFirst.SetStringDefaultLength(200).InitTables(typeof(Order), typeof(OrderItem));//
db.Insertable(new Order()
{
Name = "order1", CreateTime = DateTime.Now
}).ExecuteCommand();
Console.WriteLine(db.CurrentConnectionConfig.DbType + ":" + db.Queryable <Order>().Count());
//use db2
db.ChangeDatabase("2");
db.DbMaintenance.CreateDatabase();//Create Database2
db.CodeFirst.SetStringDefaultLength(200).InitTables(typeof(Order), typeof(OrderItem));
db.Insertable(new Order()
{
Name = "order1", CreateTime = DateTime.Now
}).ExecuteCommand();
Console.WriteLine(db.CurrentConnectionConfig.DbType + ":" + db.Queryable <Order>().Count());
// Example 1
Console.WriteLine("Example 1");
try
{
db.BeginTran();
db.ChangeDatabase("1");//use db1
db.Deleteable <Order>().ExecuteCommand();
Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType);
Console.WriteLine(db.Queryable <Order>().Count());
db.ChangeDatabase("2");//use db2
db.Deleteable <Order>().ExecuteCommand();
Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType);
Console.WriteLine(db.Queryable <Order>().Count());
throw new Exception();
db.CommitTran();
}
catch
{
db.RollbackTran();
Console.WriteLine("---Roll back");
db.ChangeDatabase("1");//use db1
Console.WriteLine(db.CurrentConnectionConfig.DbType);
Console.WriteLine(db.Queryable <Order>().Count());
db.ChangeDatabase("2");//use db2
Console.WriteLine(db.CurrentConnectionConfig.DbType);
Console.WriteLine(db.Queryable <Order>().Count());
}
// Example 2
Console.WriteLine("Example 2");
var result = db.UseTran(() =>
{
db.ChangeDatabase("1");//use db1
db.Deleteable <Order>().ExecuteCommand();
Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType);
Console.WriteLine(db.Queryable <Order>().Count());
db.ChangeDatabase("2");//use db2
db.Deleteable <Order>().ExecuteCommand();
Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType);
Console.WriteLine(db.Queryable <Order>().Count());
throw new Exception("");
});
if (result.IsSuccess == false)
{
Console.WriteLine("---Roll back");
db.ChangeDatabase("1");//use db1
Console.WriteLine(db.CurrentConnectionConfig.DbType);
Console.WriteLine(db.Queryable <Order>().Count());
db.ChangeDatabase("2");//use db2
Console.WriteLine(db.CurrentConnectionConfig.DbType);
Console.WriteLine(db.Queryable <Order>().Count());
}
// Example 3
Console.WriteLine("Example 3");
var result2 = db.UseTranAsync(() =>
{
db.ChangeDatabase("1");//use db1
db.Deleteable <Order>().ExecuteCommand();
Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType);
Console.WriteLine(db.Queryable <Order>().Count());
db.ChangeDatabase("2");//use db2
db.Deleteable <Order>().ExecuteCommand();
Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType);
Console.WriteLine(db.Queryable <Order>().Count());
throw new Exception("");
});
result2.Wait();
if (result.IsSuccess == false)
{
Console.WriteLine("---Roll back");
db.ChangeDatabase("1");//use sqlserver
Console.WriteLine(db.CurrentConnectionConfig.DbType);
Console.WriteLine(db.Queryable <Order>().Count());
db.ChangeDatabase("2");//use mysql
Console.WriteLine(db.CurrentConnectionConfig.DbType);
Console.WriteLine(db.Queryable <Order>().Count());
}
Console.WriteLine("#### Distributed TransactionExample End ####");
}
/// <summary>
/// 根据主键删除
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <bool> DeleteByIdAsync(object id)
{
var i = await Task.Run(() => db.Deleteable <TEntity>(id).ExecuteCommand());
return(i > 0);
}
public static void Init()
{
Console.WriteLine("");
Console.WriteLine("#### CodeFirst Start ####");
SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
{
DbType = DbType.MySql,
ConnectionString = Config.ConnectionString,
InitKeyType = InitKeyType.Attribute,
IsAutoCloseConnection = true
});
db.Aop.OnLogExecuted = (s, p) =>
{
Console.WriteLine(s);
};
//初始化分表
db.CodeFirst.SplitTables().InitTables <OrderSpliteTest>();
Console.WriteLine();
//根据最近3个表进行查询
var list = db.Queryable <OrderSpliteTest>().Where(it => it.Pk == Guid.NewGuid())
.SplitTable(tabs => tabs.Take(3))
.Where(it => it.Time == DateTime.Now).ToOffsetPage(1, 2);
Console.WriteLine();
//根据时间选出的表进行查询
var list2 = db.Queryable <OrderSpliteTest>().SplitTable(tabs => tabs.Where(it => it.Date >= DateTime.Now.AddYears(-2))).ToList();
Console.WriteLine();
//删除数据只在最近3张表执行操作
var x = db.Deleteable <OrderSpliteTest>().Where(it => it.Pk == Guid.NewGuid()).SplitTable(tabs => tabs.Take(3)).ExecuteCommand();
Console.WriteLine();
var tableName = db.SplitHelper <OrderSpliteTest>().GetTableName(DateTime.Now.AddDays(-1));
var tableName2 = db.SplitHelper(new OrderSpliteTest()
{
Time = DateTime.Now
}).GetTableNames();
var tableName3 = db.SplitHelper(new List <OrderSpliteTest> {
new OrderSpliteTest()
{
Time = DateTime.Now
},
new OrderSpliteTest()
{
Time = DateTime.Now
},
new OrderSpliteTest()
{
Time = DateTime.Now.AddMonths(-10)
}
}).GetTableNames();
var x2 = db.Updateable <OrderSpliteTest>()
.SetColumns(it => it.Name == "a")
.Where(it => it.Pk == Guid.NewGuid())
.SplitTable(tabs => tabs.InTableNames(tableName2))
.ExecuteCommand();
Console.WriteLine();
//按日分表
var x3 = db.Insertable(new OrderSpliteTest()
{
Name = "A"
}).SplitTable().ExecuteCommand();
Console.WriteLine();
////强制分表类型
var x4 = db.Insertable(new OrderSpliteTest()
{
Name = "A", Time = DateTime.Now.AddDays(-1)
}).SplitTable().ExecuteCommand();
Console.WriteLine("#### CodeFirst end ####");
}
/// <summary>
/// 删除账户.
/// </summary>
/// <param name="userId">账户编号.</param>
/// <returns>Json.</returns>
public ActionResult DelUser(int userId)
{
Db.Deleteable <User>().Where(it => it.Id == userId).ExecuteCommand();
return(Json(new { code = 200 }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 根据用户名删除
/// </summary>
/// <param name="userList"></param>
/// <returns></returns>
int IUserListDAL.DeleteByName(UserList userList)
{
return(db.Deleteable <UserList>().In(userList.uname).ExecuteCommand());
}
/// <summary>
/// 根据实体删除一条数据
/// </summary>
/// <param name="entity">博文实体类</param>
/// <returns></returns>
public static async Task <bool> Delete <TEntity>(this SqlSugarClient db, TEntity entity) where TEntity : EntityBase, new()
{
var i = await Task.Run(() => db.Deleteable(entity).ExecuteCommand());
return(i > 0);
}
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids">主键ID集合</param>
/// <returns></returns>
public static async Task <bool> DeleteByIds <TEntity>(this SqlSugarClient db, object[] ids) where TEntity : EntityBase, new()
{
var i = await Task.Run(() => db.Deleteable <TEntity>().In(ids).ExecuteCommand());
return(i > 0);
}
/// <summary>
/// 物理删除
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public bool Delete(int id)
{
return(Db.Deleteable <T>().In(id).ExecuteCommand() > -1);
}
public int DeleteEntity(CodeTemplet t)
{
return(db.Deleteable(t).ExecuteCommand());
}
public bool Delete(User model)
{
var i = db.Deleteable(model).ExecuteCommand();
return(i > 0);
}
public bool Delete(Advertisement model)
{
var i = db.Deleteable(model).ExecuteCommand();
return(i > 0);
}
public static void EmployeeUpdateForDingTalk(SqlSugarClient Edb, SqlSugarClient Ddb, List <V_EmployeeToDingTalk> ESB_EmployeeList)
{
NLogHelper log = NLogFactory.GetLogger("EmployeeUpdateForDingTalk");
List <V_EmployeeToDingTalk> EmpList = new List <V_EmployeeToDingTalk>();
//获取ESB中目前已经更新的数据
List <V_OperationObject> OperationList = Tbiz_OperationTempBll.GetOperationList(Edb, 1, 0);
//根据ESB操作记录中更新的ID，查出目前的用户信息
List <V_EmployeeToDingTalk> EmployeeList = ESB_EmployeeList.Where(p => OperationList.Exists(q => q.UserId == p.UserId)).ToList();
log.Info("\r\n------------------------------------------------根据ESB更新钉钉中的人员信息------------------------------------------------\r\n");
#region 循环更新到钉钉
foreach (var item in EmployeeList)
{
if (item.Enabled == 1)
{
string EmployeeJson = GetEmployee(item.UserId);
//用户ID在钉钉中不存在，即：离职用户重新录用时，应将该用户重新添加进钉钉
if (EmployeeJson.Equals("-1"))
{
AddEmployee(Edb, Ddb, item);
EmpList.Add(item);
continue;
}
else
{
EmployeeEntity model = Newtonsoft.Json.JsonConvert.DeserializeObject <EmployeeEntity>(EmployeeJson);
string oldMobile = model.mobile;
string DD_DepartmentId = "1";
DepartmentResult DD_DepModel = Ddb.Queryable <DepartmentResult>().With(SqlWith.NoLock).Where(it => it.ESB_DepartmentID.Equals(item.ESB_DepartmentId)).First();
if (DD_DepModel == null)
{
try
{
DD_DepartmentId = DepartmentForDingTalkBll.DD_DepartmentIsNullForDingTalk(Edb, Ddb, item.ESB_DepartmentId);
}
catch (Exception ex)
{
DD_DepartmentId = DepartmentForDingTalkBll.DD_DepartmentIsNullForDingTalk(Edb, Ddb, item.ESB_DepartmentId);
}
}
else
{
DD_DepartmentId = DD_DepModel.id;
}
model.userid = item.UserId;
model.name = item.Name;
model.department = new List <int>(new int[] { Convert.ToInt32(DD_DepartmentId) });
model.position = item.PositionName;
model.mobile = item.Mobile;
model.tel = item.Telephone;
model.email = item.Email;
model.jobnumber = item.UserId;
string param = JsonConvert.SerializeObject(model);
Result Result = EmployeeBll.Update(param);
if (Result != null)
{
if (Result.errcode == "0")
{
EmpList.Add(item);
//Console.Write("更新成功," + Result.errmsg);
}
else
{
//UserID不存在
if (Result.errcode == "60111")
{
AddEmployee(Edb, Ddb, item);
EmpList.Add(item);
continue;
}
//更新手机号出错时
else if (Result.errcode == "40022" || Result.errcode == "40021" || Result.errcode == "60104" || Result.errcode == "60121")
{
//40021 更换的号码已注册过钉钉，无法使用该号码
//40022 企业中的手机号码和登陆钉钉的手机号码不一致,暂时不支持修改用户信息,可以删除后重新添加
//60104 手机号码在公司中已存在
//60121 找不到该用户
string Deletecode = EmployeeBll.Delete(model.userid).errcode;
string Createcode = EmployeeBll.Create(JsonConvert.SerializeObject(model)).errcode;
if (Createcode != "0")
{
Createcode = EmployeeBll.Create(JsonConvert.SerializeObject(model)).errcode;
if (Createcode != "0" && Createcode != "40021")
{
log.Error("\r\n EmployeeUpdateForDingTalk - 行号135 更新钉钉人员信息时，成功删除员工信息，但是创建员工信息时报错，错误编码如下：" + Createcode + ", 员工编号为：" + model.userid);
}
}
EmpList.Add(item);
Task.Factory.StartNew(() =>
{
InsertErroUpdateEmployee(model.userid, oldMobile, item.Mobile, Result.errcode);
if (Deletecode != "0")
{
InsertErroUpdateEmployee(model.userid, oldMobile, item.Mobile, "删除失败，错误编号：" + Deletecode);
}
if (Createcode != "0")
{
InsertErroUpdateEmployee(model.userid, oldMobile, item.Mobile, "执行删除后创建失败，错误编号：" + Createcode);
}
});
//Console.Write("更新成功\r\n");
}
else
{
//手机号码不合法
if (Result.errcode == "60103")
{
model.mobile = oldMobile;
Result = EmployeeBll.Update(JsonConvert.SerializeObject(model));
if (Result.errcode == "0")
{
EmpList.Add(item);
}
else
{
log.Error("\r\n EmployeeForDingTalkBll-EmployeeUpdateForDingTalk() 失败后不更新手机号，还是失败，具体信息： " + Result.errmsg + "; UserId=" + item.UserId);
}
}
//部门在钉钉中不存在的时候
else if (Result.errcode == "60003")
{
model.department = new List <int>(new int[] { 1 });
param = JsonConvert.SerializeObject(model);
Result r = EmployeeBll.Update(param);
if (r.errcode == "0")
{
EmpList.Add(item);
}
else if (r.errcode == "40022" || r.errcode == "40021" || r.errcode == "60104" || r.errcode == "60121")
{
//40021 更换的号码已注册过钉钉，无法使用该号码
//40022 企业中的手机号码和登陆钉钉的手机号码不一致,暂时不支持修改用户信息,可以删除后重新添加
//60104 手机号码在公司中已存在
//60121 找不到该用户
string Deletecode = EmployeeBll.Delete(model.userid).errcode;
string Createcode = EmployeeBll.Create(JsonConvert.SerializeObject(model)).errcode;
if (Createcode != "0")
{
Createcode = EmployeeBll.Create(JsonConvert.SerializeObject(model)).errcode;
if (Createcode != "0" && Createcode != "40021")
{
log.Error("\r\n EmployeeUpdateForDingTalk - 行号199 更新钉钉人员信息时，成功删除员工信息，但是创建员工信息时报错，错误编码如下：" + Createcode);
}
}
EmpList.Add(item);
Task.Factory.StartNew(() =>
{
InsertErroUpdateEmployee(model.userid, oldMobile, item.Mobile, r.errcode);
if (Deletecode != "0")
{
InsertErroUpdateEmployee(model.userid, oldMobile, item.Mobile, "删除失败，错误编号：" + Deletecode);
}
if (Createcode != "0")
{
InsertErroUpdateEmployee(model.userid, oldMobile, item.Mobile, "执行删除后创建失败，错误编号：" + Createcode);
}
});
//Console.Write("更新成功\r\n");
}
else
{
log.Debug("\r\n EmployeeForDingTalkBll-EmployeeUpdateForDingTalk() 钉钉中部，部门id=" + DD_DepartmentId + ",已将该人员挂在公司下，" + Result.errmsg + "; UserId=" + item.UserId);
Task.Factory.StartNew(() =>
{
InsertErroUpdateEmployee(model.userid, oldMobile, item.Mobile, "更新用户时失败，错误编号：" + Result.errcode);
});
}
}
else
{
log.Error("\r\n EmployeeForDingTalkBll-EmployeeUpdateForDingTalk() " + Result.errmsg + "; UserId=" + item.UserId);
Task.Factory.StartNew(() =>
{
InsertErroUpdateEmployee(model.userid, oldMobile, item.Mobile, "更新用户时失败，错误编号：" + Result.errcode);
});
}
}
}
}
else
{
//Console.Write("无返回数据");
}
}
}
else
{
Result Result = EmployeeBll.Delete(item.UserId);
if (Result != null)
{
//找不到该用户
if (Result.errcode == "0" || Result.errcode == "60121")
{
EmpList.Add(item);
//Console.Write("删除成功," + Result.errmsg + "\r\n");
}
else
{
log.Error("\r\n EmployeeForDingTalkBll-EmployeeUpdateForDingTalk() " + Result.errmsg + "; UserId=" + item.UserId);
//Console.Write("\r\n" + Result.errmsg + "; UserId=" + item.UserId);
}
}
else
{
//Console.Write("无返回数据");
}
}
}
int d = 0;
foreach (var item in EmpList)
{
d = Edb.Deleteable <Tbiz_OperationTemp>().Where(it => it.ObjectId.Equals(item.UserId)).ExecuteCommand();
}
#endregion
}
public bool Delete(Expression <Func <T, bool> > expression)
{
return(_db.Deleteable <T>().Where(expression).ExecuteCommand() > 0);
}
/// <summary>
/// 物理删除实体对象
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <param name="db"></param>
/// <param name="deleteObj"></param>
/// <returns></returns>
//public static async Task<bool> Delete<TSource>(this SqlSugarClient db, TSource deleteObj) where TSource : EntityBase, new()
//{
// return await Task.Run(()=> db.Deleteable<TSource>().Where(deleteObj).ExecuteCommand() > 0);
//}
/// <summary>
/// 物理删除实体对象
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <param name="db"></param>
/// <param name="whereExp">条件表达式</param>
/// <returns></returns>
public static async Task <bool> Delete <TSource>(this SqlSugarClient db, Expression <Func <TSource, bool> > whereExp) where TSource : EntityBase, new()
{
return(await Task.Run(() => db.Deleteable <TSource>().Where(whereExp).ExecuteCommand() > 0));
}
public int DeleteEntity(LoginUserPwd t)
{
return(db.Deleteable(t).ExecuteCommand());
}
/// <summary>
/// 通过实体删除
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <bool> delete(T model)
{
var i = await Task.Run(() => db.Deleteable <T>(model).ExecuteCommand());
return((int)i > 0);
}
/// <summary>
/// 根据实体删除一条数据
/// </summary>
/// <param name="entity">博文实体类</param>
/// <returns></returns>
public async Task <bool> Delete(TEntity entity)
{
var i = await db.Deleteable(entity).ExecuteCommandAsync();
return(i > 0);
}
public static void Init()
{
Console.WriteLine("");
Console.WriteLine("#### CodeFirst Start ####");
SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
{
DbType = DbType.SqlServer,
ConnectionString = Config.ConnectionString,
InitKeyType = InitKeyType.Attribute,
IsAutoCloseConnection = true
});
db.Aop.OnLogExecuted = (s, p) =>
{
Console.WriteLine(s);
Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value)));
};
//初始化分表
db.CodeFirst.SplitTables().InitTables <OrderSpliteTest>();
Console.WriteLine();
//根据最近3个表进行查询
var list = db.Queryable <OrderSpliteTest>()
.SplitTable(DateTime.Now.Date.AddYears(-1), DateTime.Now)
.ToList();
var first = db.Queryable <OrderSpliteTest>()
.SplitTable(DateTime.MaxValue, DateTime.Now)
.First();//no table
Console.WriteLine();
//根据时间选出的表进行查询
var list2 = db.Queryable <OrderSpliteTest>().SplitTable(tabs => tabs.Where(it => it.Date >= DateTime.Now.AddYears(-2))).ToList();
Console.WriteLine();
//删除数据只在最近3张表执行操作
var x = db.Deleteable <OrderSpliteTest>().Where(it => it.Pk == Guid.NewGuid()).SplitTable(tabs => tabs.Take(3)).ExecuteCommand();
Console.WriteLine();
var tableName = db.SplitHelper <OrderSpliteTest>().GetTableName(DateTime.Now.AddDays(-111));
var listNull = db.Queryable <OrderSpliteTest>().SplitTable(ta => ta.InTableNames(tableName)).ToList();
var tableName2 = db.SplitHelper(new OrderSpliteTest()
{
Time = DateTime.Now
}).GetTableNames();
var tableName3 = db.SplitHelper(new List <OrderSpliteTest> {
new OrderSpliteTest()
{
Time = DateTime.Now
},
new OrderSpliteTest()
{
Time = DateTime.Now
},
new OrderSpliteTest()
{
Time = DateTime.Now.AddMonths(-10)
}
}).GetTableNames();
var x2 = db.Updateable <OrderSpliteTest>()
.SetColumns(it => it.Name == "a")
.Where(it => it.Pk == Guid.NewGuid())
.SplitTable(tabs => tabs.InTableNames(tableName2))
.ExecuteCommand();
Console.WriteLine();
//按日分表
var x3 = db.Insertable(new OrderSpliteTest()
{
Name = "A"
}).SplitTable().ExecuteCommand();
Console.WriteLine();
////强制分表类型
var x4 = db.Insertable(new OrderSpliteTest()
{
Name = "A", Time = DateTime.Now.AddDays(-1)
}).SplitTable().ExecuteCommand();
//分表支持BulkCopy
db.Fastest <OrderSpliteTest>().SplitTable().BulkCopy(new List <OrderSpliteTest> {
new OrderSpliteTest()
{
Pk = Guid.NewGuid(), Name = "a", Time = DateTime.Now
},
new OrderSpliteTest()
{
Pk = Guid.NewGuid(), Name = "a", Time = DateTime.Now
},
new OrderSpliteTest()
{
Pk = Guid.NewGuid(), Name = "a", Time = DateTime.Now.AddMonths(-10)
}
});
db.Fastest <OrderSpliteTest>().SplitTable().BulkUpdate(db.Queryable <OrderSpliteTest>().SplitTable(it => it).ToList());
db.Fastest <OrderSpliteTest>().SplitTable().BulkUpdate(db.Queryable <OrderSpliteTest>().SplitTable(it => it).ToList(), new string[] { "pk" }, new string[] { "name" });
Console.WriteLine("#### CodeFirst end ####");
}
/// <summary>
/// 根据实体删除一条数据
/// </summary>
/// <param name="model">实体类</param>
/// <returns></returns>
public async Task <bool> Delete(TEntity model)
{
var delete = _db.Deleteable(model);
return(await delete.ExecuteCommandHasChangeAsync());
}
public bool Delete(T entity)
{
var deleteable = DB.Deleteable(entity);
return(deleteable.ExecuteCommand() > 0);
}
/// <summary>
/// 删除账户.
/// </summary>
/// <param name="adminId">账户编号.</param>
/// <returns>Json.</returns>
public ActionResult DelAdmin(int adminId)
{
Db.Deleteable <Admin>().Where(it => it.Id == adminId).ExecuteCommand();
return(Json(new { code = 200 }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 删除实体
/// </summary>
/// <param name="deleteObj"></param>
/// <returns></returns>
public bool Delete(T deleteObj)
{
return(Sqldb.Deleteable <T>().Where(deleteObj).ExecuteCommand() > 0);
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
public SugarWDeletable(SqlSugarClient client)
{
_deletable = client.Deleteable <T>();
}
public void Delete(T entity)
{
db.Deleteable(entity).ExecuteCommand();
}
/// <summary>
/// 删除一条数据
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public int Delete(T info)
{
return(Db.Deleteable <T>(info).ExecuteCommand());
}
/// <summary>
/// 删除招聘信息.
/// </summary>
/// <param name="recruitId">招聘编号.</param>
/// <returns>Json.</returns>
public ActionResult DelRecruit(int recruitId)
{
Db.Deleteable <Recruitment>().Where(it => it.Id == recruitId).ExecuteCommand();
return(Json(new { code = 200 }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 根据实体删除一条数据
/// </summary>
/// <param name="entity">博文实体类</param>
/// <returns></returns>
public async Task <bool> Delete(TEntity entity)
{
var i = await Task.Run(() => _db.Deleteable(entity).ExecuteCommand());
return(i > 0);
}
public int DelMenu(List <int> ids)
{
return(db.Deleteable <B_TbMenu>().With(SqlWith.RowLock).Where(it => ids.Contains(it.ID)).ExecuteCommand());
}
