public bool SaveT_Result(T_Result result)
{
bool res = false;
if (result.ID == 0)
{
Mapper.BeginTransaction();
try
{
if (result.Picture != null)
{
Mapper.Insert("InsertT_Picture", result.Picture);
result.PictureID = result.Picture.ID;
}
Mapper.Insert("InsertT_Result", result);
Mapper.CommitTransaction();
res = true;
}
catch (Exception ex)
{
Tool.AppLogError(ex);
Mapper.RollBackTransaction();
}
}
return(res);
}
/// <summary>删除记录</summary>
/// <param name="ids">标识,多个以逗号隔开.</param>
public void Delete(string ids)
{
if (string.IsNullOrEmpty(ids))
{
return;
}
try
{
ibatisMapper.BeginTransaction();
Dictionary <string, object> args = new Dictionary <string, object>();
// args.Add("ApplicationStore", ForumUtility.ToDataTablePrefix(applicationTag));
// 删除主题信息
args.Add("WhereClause", string.Format(" Id IN ('{0}') ", StringHelper.ToSafeSQL(ids).Replace(",", "','")));
this.ibatisMapper.Delete(StringHelper.ToProcedurePrefix(string.Format("{0}_Delete(PhysicallyRemoved)", this.tableName)), args);
ibatisMapper.CommitTransaction();
}
catch (Exception ex)
{
ibatisMapper.RollBackTransaction();
throw ex;
}
}
public bool UpdateOrInsertCamera(T_Camera t_Camera)
{
bool result = false;
var session = mapper.BeginTransaction();
try
{
if (t_Camera.ID == 0)
{
mapper.Insert("InsertT_Camera", t_Camera);
result = t_Camera.ID > 0;
}
else
{
result = mapper.Update("UpdateT_Camera", t_Camera) > 0;
}
mapper.CommitTransaction();
}
catch (Exception e)
{
result = false;
mapper.RollBackTransaction();
}
return(result);
}
public static object InsertUserToGame(string userid, string gameid)
{
ISqlMapper mapper = GetSqlMapper.GetMapper();
int result = 0;
Hashtable hashTable = new Hashtable();
hashTable.Add("UserID", userid);
hashTable.Add("GameID", gameid);
try
{
mapper.BeginTransaction();
result = mapper.QueryForObject <int>("IsExistUserToGame", hashTable);
mapper.CommitTransaction();
}
catch { }
if (result == 0)
{
object oj = null;
try
{
mapper.BeginTransaction();
oj = mapper.Insert("InsertUserToGame", hashTable);
mapper.CommitTransaction();
}
catch { }
return(oj);
}
return(null);
}
public string Delete(object condition, bool RemoveTerno)
{
ISqlMapper NewMap = SqlMapper.Instance();
NewMap.BeginTransaction();
try
{
if (RemoveTerno == true)
{
ExecuteUpdateTrans("TerminalInfo.TerminalRemoveBindByGuid", condition, NewMap);
NewMap.CommitTransaction();
}
else
{
//根据车全部删除
ExecuteUpdateTrans("TerminalInfo.TerminalRemoveBind", condition, NewMap);
//删除跟更改调同一个方法。
ExecuteUpdateTrans("CarInfo.DeleteCarInfo", condition, NewMap);
ExecuteUpdateTrans("FieldValues.DeleteFieldValues", condition, NewMap);
NewMap.CommitTransaction();
}
return("true");
}
catch (Exception e)
{
NewMap.RollBackTransaction();
return("false");
}
}
public int Delete(object condition)
{
ISqlMapper NewMap = SqlMapper.Instance();
NewMap.BeginTransaction();
try
{
object o = ExecuteQueryForObjectTrans("UserInfo.SelectUserInfoCount", condition, NewMap);
if (Convert.ToInt32(o) > 0)
{
NewMap.CommitTransaction();
return(-2);
}
else
{
ExecuteUpdateTrans("RoleInfo.DeleteRoleInfo", condition, NewMap);
NewMap.CommitTransaction();
return(1);
}
}
catch (Exception e)
{
NewMap.RollBackTransaction();
return(-1);
}
}
//public int GetRoleManuCount(string RmId)
//{
// object count = ExecuteQueryForObject("RoleManu.GetRoleManuCountById", RmId);
// return (int)count;
//}
public string AddRM(RoleManu rm)
{
ISqlMapper NewMap = SqlMapper.Instance();
try
{
NewMap.BeginTransaction();
object c = ExecuteQueryForObjectTrans("RoleManu.SelectRoleCountByRoleAndMenu", rm, NewMap);
if ((int)c == 0)
{
rm.RmId = System.Guid.NewGuid().ToString();
ExecuteInsertTrans("RoleManu.InsertRoleManu", rm, NewMap);
NewMap.CommitTransaction();
return("true");
}
else
{
NewMap.CommitTransaction();
return("该角色已经分配此权限");
}
}
catch (Exception e)
{
NewMap.RollBackTransaction();
return("false");
}
}
/// <summary>
/// 移动好友
/// </summary>
/// <param name="userid">用户id</param>
/// <param name="friendid">好友id</param>
/// <param name="groupid"></param>
/// <returns></returns>
public static int MoveFriend(string userid, string friendid, string groupid)
{
ISqlMapper mapper = GetSqlMapper.GetMapper();
int result = 0;
Hashtable hashTable = new Hashtable();
hashTable.Add("UserID", userid);
hashTable.Add("FriendID", friendid);
hashTable.Add("GroupID", groupid);
try
{
mapper.BeginTransaction();
result = mapper.Update("MoveFriend1", hashTable);
mapper.CommitTransaction();
}
catch { }
if (result == 0)
{
try
{
mapper.BeginTransaction();
result = mapper.Update("MoveFriend2", hashTable);
mapper.CommitTransaction();
}
catch { }
}
return(result);
}
/// <summary>
/// 更新Sheet对应的流程信息
/// </summary>
public static int UpdateProcedureMap(int sheetID, string procedureMap)
{
ISqlMapper mapper = GetSqlMapper.GetMapper();
int result = 0;
try
{
mapper.BeginTransaction();
result = mapper.QueryForObject <int>("SheetIsExistInProcedure", sheetID);
mapper.CommitTransaction();
}
catch (Exception ex)
{
applog.InfoFormat("Access.UpdateProcedureMap()--Search Error:{0}", ex.Message);
mapper.RollBackTransaction();
return(result);
}
Hashtable hashTable = new Hashtable();
hashTable.Add("SheetID", sheetID);
hashTable.Add("ProcedureMap", procedureMap);
if (result == 0)
{
try
{
mapper.BeginTransaction();
mapper.Insert("InsertProcedureMap", hashTable);
mapper.CommitTransaction();
result = 1;
}
catch (Exception ex)
{
applog.InfoFormat("Access.UpdateProcedureMap()--Insert Error:{0}", ex.Message);
mapper.RollBackTransaction();
}
}
else
{
try
{
mapper.BeginTransaction();
mapper.Update("UpdateProcedureMapBySheet", hashTable);
mapper.CommitTransaction();
result = 1;
}
catch (Exception ex)
{
applog.InfoFormat("Access.UpdateProcedureMap()--Update Error:{0}", ex.Message);
mapper.RollBackTransaction();
}
}
return(result);
}
/// <summary>
/// 修改一个业务通告
/// </summary>
/// <param name="loggingSession">当前登录的信息</param>
/// <param name="announce">要修改的业务通告</param>
/// <returns></returns>
public bool ModifyAnnounce(LoggingSessionInfo loggingSession, AnnounceInfo announce)
{
if (announce.AnnounceUnits == null || announce.AnnounceUnits.Count == 0)
{
throw new ArgumentNullException("announce.AnnounceUnits");
}
announce.ModifyUserID = loggingSession.CurrentUser.User_Id;
announce.ModifyUserName = loggingSession.CurrentUser.User_Name;
//保存
ISqlMapper sqlMap = cSqlMapper.Instance(loggingSession.CurrentLoggingManager);
try
{
sqlMap.BeginTransaction();
//修改通告信息
sqlMap.Update("Exchange.Announce.Update", announce);
//删除通告与单位的关系
sqlMap.Delete("Exchange.AnnounceUnit.DeleteByAnnounceID", announce.ID);
//插入通告与单位的关系
foreach (AnnounceUnitInfo au in announce.AnnounceUnits)
{
au.Announce = announce;
sqlMap.Insert("Exchange.AnnounceUnit.InsertAnnounceUnit", au);
}
sqlMap.CommitTransaction();
}
catch (Exception ex)
{
sqlMap.RollBackTransaction();
throw ex;
}
return(true);
}
/// <summary>
/// 获取单个业务通告信息
/// </summary>
/// <param name="loggingSession">当前登录的信息</param>
/// <param name="announceID">业务通告ID</param>
/// <returns></returns>
public AnnounceQueryInfo GetAnnounceByID(LoggingSessionInfo loggingSession, string announceID)
{
AnnounceQueryInfo announce = null;
ISqlMapper sqlMap = cSqlMapper.Instance(loggingSession.CurrentLoggingManager);
try
{
sqlMap.BeginTransaction();
//获取通告信息
announce = sqlMap.QueryForObject <AnnounceQueryInfo>("Exchange.Announce.SelectByID", announceID);
if (announce != null)
{
//获取通告与单位的关系
announce.AnnounceUnits = sqlMap.QueryForList <AnnounceUnitInfo>("Exchange.AnnounceUnit.SelectByAnnounceID", announceID);
}
sqlMap.CommitTransaction();
}
catch (Exception ex)
{
sqlMap.RollBackTransaction();
throw ex;
}
return(announce);
}
public void Commit()
{
if (mapper != null)
{
mapper.CommitTransaction();
}
}
public string RemoveBind(string TerGuids)
{
ISqlMapper NewMap = SqlMapper.Instance();
NewMap.BeginTransaction();
try
{
string[] TerGuidArr = TerGuids.Split(',');
for (int i = 0; i < TerGuidArr.Length; i++)
{
string carId = ExecuteQueryForObject("TerminalInfo.SelectCarIdByTerGuid", TerGuidArr[i]).ToString();
int cnt = GetTerminalByCarId(carId);
if (cnt > 1)
{
ExecuteUpdateTrans("TerminalInfo.TerminalRemoveBindByGuid", TerGuidArr[i], NewMap);
}
else
{
ExecuteUpdateTrans("CarInfo.DeleteCarInfo", carId, NewMap); //ɾ³ý³µÁ¾
ExecuteUpdateTrans("TerminalInfo.TerminalRemoveBindByGuid", TerGuidArr[i], NewMap);
}
}
NewMap.CommitTransaction();
return("true");
}
catch (Exception e)
{
NewMap.RollBackTransaction();
return("false");
}
}
public string UpdateSendInfoFailByOldId(string oldid, string status, string resultStr, double sendId)
{
ISqlMapper NewMap = SqlMapper.Instance();
NewMap.BeginTransaction();
try
{
Sendinfo si = new Sendinfo();
si.SendinfoStatus = Convert.ToDouble(status);
si.Resultstr = resultStr;
si.Id = sendId;
ExecuteUpdateTrans("Sendinfo.UpdateSendinfoFail", si, NewMap);
SendinfoLast SFL = new SendinfoLast();
SFL.OldId = Convert.ToDouble(oldid);
SFL.SendinfoStatus = Convert.ToDouble(status);
SFL.Resultstr = resultStr;
ExecuteUpdateTrans("SendinfoLast.UpdateSendinfoLastFailByOldId", si, NewMap);
NewMap.CommitTransaction();
return("true");
}
catch (Exception e)
{
NewMap.RollBackTransaction();
return("false");
}
}
public string UpdateCarType(CarInfo ci, string CarTypeName)
{
ISqlMapper NewMap = SqlMapper.Instance();
NewMap.BeginTransaction();
try
{
if (ci.TypeId == null || ci.TypeId.ToString().Trim() == "")
{
CarType ct = new CarType();
ct.TypeId = System.Guid.NewGuid().ToString();
ct.TypeName = CarTypeName;
ct.DeptId = ci.Businessdivisionid;
ct.TypeIsdel = "0";
ExecuteInsertTrans("CarType.InsertCarType", ct, NewMap);
ci.TypeId = ct.TypeId;
ExecuteUpdateTrans("CarInfo.UpdateCarInfoByCarNo", ci, NewMap);
}
else
{
ExecuteUpdateTrans("CarInfo.UpdateCarInfoByCarNo", ci, NewMap);
}
NewMap.CommitTransaction();
return("true");
}
catch (Exception e)
{
NewMap.RollBackTransaction();
return("false");
}
}
public string UpdateCarInfo(ArrayList arr, string CarTypeName)
{
ISqlMapper NewMap = SqlMapper.Instance();
NewMap.BeginTransaction();
try
{
for (int i = 0; i < arr.Count; i++)
{
Type typeName = arr[i].GetType();
switch (typeName.FullName)
{
case "GModel.Car.CarInfo":
CarInfo ci = (CarInfo)arr[i];
if (ci.TypeId == null || ci.TypeId.ToString().Trim() == "")
{
CarType ct = new CarType();
ct.TypeId = System.Guid.NewGuid().ToString();
ct.TypeName = CarTypeName;
ct.DeptId = ci.Businessdivisionid;
ct.TypeIsdel = "0";
ExecuteInsertTrans("CarType.InsertCarType", ct, NewMap);
ci.TypeId = ct.TypeId;
ExecuteUpdateTrans("CarInfo.UpdateCarInfo", ci, NewMap); // ExecuteUpdateTrans("CarInfo.UpdateCarInfo", ci, NewMap);
}
else
{
ExecuteUpdateTrans("CarInfo.UpdateCarInfo", ci, NewMap); // ExecuteUpdateTrans("CarInfo.UpdateCarInfo", ci, NewMap);
}
//修改终端的对应信息
ExecuteUpdateTrans("CarInfo.UpdateTerInfoByCarId", ci, NewMap);
TerminalInfo ti = new TerminalInfo();
ti.CarId = ci.CarId;
ti.TerCarno = ci.CarNo;
ExecuteUpdateTrans("TerminalInfo.UpdateTerCarNo", ti, NewMap);
break;
case "GModel.Car.FieldValues":
if (((FieldValues)arr[i]).FieldId.Trim() != "")
{
ExecuteUpdateTrans("FieldValues.UpdateFieldValues", (FieldValues)arr[i], NewMap);
}
else
{
FieldValues fv = (FieldValues)arr[i];
fv.FieldId = System.Guid.NewGuid().ToString();
ExecuteInsertTrans("FieldValues.InsertFieldValues", fv, NewMap);
}
break;
}
}
NewMap.CommitTransaction();
return("true");
}
catch (Exception e)
{
NewMap.RollBackTransaction();
return("false");
}
}
/// <summary>
/// 假删除
/// </summary>
/// <param name="condition"></param>
/// <returns></returns>
public string Delete(object condition)
{
ISqlMapper NewMap = SqlMapper.Instance();
NewMap.BeginTransaction();
try
{
object count = ExecuteQueryForObjectTrans("CarInfo.SelectCarInfoCountByCarType", condition, NewMap);
if ((int)count > 0)
{
NewMap.RollBackTransaction();
return("ExistCar");
}
else
{
ExecuteUpdateTrans("CarType.DeleteCarType", condition, NewMap);
NewMap.CommitTransaction();
return("true");
}
}
catch (Exception e)
{
NewMap.RollBackTransaction();
return("false");
}
}
/// <summary>
/// Releasing, or resetting resources.
/// </summary>
public void Dispose()
{
if (_isTransactionOpen == false)
{
if (_connection.State != ConnectionState.Closed)
{
_sqlMapper.CloseConnection();
}
}
else
{
if (_consistent)
{
_sqlMapper.CommitTransaction();
_isTransactionOpen = false;
}
else
{
if (_connection.State != ConnectionState.Closed)
{
_sqlMapper.RollBackTransaction();
_isTransactionOpen = false;
}
}
}
}
public string BindTerCar(string TerIds, string CarId)
{
ISqlMapper NewMap = SqlMapper.Instance();
NewMap.BeginTransaction();
try
{
if (TerIds != null && TerIds.Trim() != "")
{
string[] ArrTer = TerIds.Split(new string[] { "&&--__" }, StringSplitOptions.RemoveEmptyEntries);
for (int k = 0; k < ArrTer.Length; k++)
{
TerminalInfo ti = new TerminalInfo();
ti.TerGuid = ArrTer[k];
ti.CarId = CarId;
ExecuteUpdateTrans("TerminalInfo.BindTerCar", ti, NewMap);
}
}
NewMap.CommitTransaction();
return("true");
}
catch (Exception)
{
NewMap.RollBackTransaction();
return("false");
}
}
public string UpdateStatusNew(string oldid, double sendid, string sendcmd, string status)
{
ISqlMapper NewMap = SqlMapper.Instance();
NewMap.BeginTransaction();
try
{
//删除跟更改调同一个方法。
Sendinfo si = new Sendinfo();
si.SendinfoStatus = Convert.ToDouble(status);
si.Sendtocmd = sendcmd;
si.Id = sendid;
ExecuteUpdateTrans("Sendinfo.UpdateSendinfo", si, NewMap);
SendinfoLast sil = new SendinfoLast();
sil.SendinfoStatus = Convert.ToDouble(status);
sil.Sendtocmd = sendcmd;
sil.OldId = Convert.ToDouble(oldid);
ExecuteUpdateTrans("SendinfoLast.UpdateSendinfoLastByOldid", sil, NewMap);
NewMap.CommitTransaction();
return("true");
}
catch (Exception e)
{
NewMap.RollBackTransaction();
return("false");
}
}
public List <TreeMode> GetMenuTreeByRoleId(string RoleId)
{
ISqlMapper NewMap = SqlMapper.Instance();
NewMap.BeginTransaction();
List <TreeMode> mTreeNode = new List <TreeMode>();
try
{
Hashtable ht = new Hashtable();
ht.Add("MenuType", "0");
ht.Add("RoleId", RoleId);
ht.Add("MenuParent", "");
IList <MenuInfo> lmi = ExecuteQueryForListTrans <MenuInfo>("MenuInfo.SelectMenuInfoByRoleId", ht, NewMap);
if (lmi != null && lmi.Count > 0)
{
for (int i = 0; i < lmi.Count; i++)
{
TreeMode treeNode = new TreeMode("");
treeNode.id = lmi[i].MenuId;
treeNode.text = lmi[i].MenuName;
treeNode.icon = lmi[i].MenuIcon;
treeNode.url = lmi[i].MenuUrl;
treeNode.children = new List <TreeMode>();
mTreeNode.Add(treeNode);
}
for (int n = 0; n < mTreeNode.Count; n++)
{
ht["MenuType"] = "1";
ht["MenuParent"] = mTreeNode[n].id;
IList <MenuInfo> lmic = ExecuteQueryForListTrans <MenuInfo>("MenuInfo.SelectMenuChildByRoleId", ht, NewMap);
if (lmic != null && lmic.Count > 0)
{
for (int m = 0; m < lmic.Count; m++)
{
TreeMode treeNode = new TreeMode("");
treeNode.id = lmic[m].MenuId;
treeNode.text = lmic[m].MenuName;
treeNode.icon = lmic[m].MenuIcon;
treeNode.url = lmic[m].MenuUrl;
mTreeNode[n].children.Add(treeNode);
}
}
}
NewMap.CommitTransaction();
return(mTreeNode);
}
else
{
NewMap.RollBackTransaction();
return(mTreeNode);
}
}
catch (Exception e)
{
NewMap.RollBackTransaction();
return(mTreeNode);
}
}
/// <summary>
/// Releasing, or resetting resources.
/// </summary>
public void Dispose()
{
if (_logger.IsDebugEnabled)
{
_logger.Debug("Dispose SqlMapSession");
}
if (_isTransactionOpen == false)
{
if (_connection.State != ConnectionState.Closed)
{
_sqlMapper.CloseConnection();
}
}
else
{
if (_consistent)
{
_sqlMapper.CommitTransaction();
_isTransactionOpen = false;
}
else
{
if (_connection.State != ConnectionState.Closed)
{
_sqlMapper.RollBackTransaction();
_isTransactionOpen = false;
}
}
}
}
public int DeleteChildren(object DeptId)
{
int k = 0;
ISqlMapper NewMap = SqlMapper.Instance();
NewMap.BeginTransaction();
try
{ //查询该企业下有没有车或者终端，如果有，提示转移车或终端再删除。
object countCar = ExecuteQueryForObjectTrans("CarInfo.SelectCarInfoCountByDeptId", DeptId, NewMap);
object countTer = ExecuteQueryForObjectTrans("TerminalInfo.SelectTerminalInfoCountByDeptId", DeptId, NewMap);
if ((int)countCar > 0 && (int)countTer > 0)
{
k = -1;
}
else if ((int)countCar > 0)
{
k = -2;
}
else if ((int)countTer > 0)
{
k = -3;
}
else
{
k = ExecuteUpdateTrans("DeptInfo.DeleteDeptByDeptId", DeptId, NewMap);
}
NewMap.CommitTransaction();
return(k);
}
catch (Exception e)
{
NewMap.RollBackTransaction();
return(-4);
}
}
/// <summary>
/// 修改一个仓库
/// </summary>
/// <param name="loggingSession">当前用户的登录信息</param>
/// <param name="warehouse">仓库信息</param>
/// <returns></returns>
public bool ModifyWarehouse(LoggingSessionInfo loggingSession, WarehouseInfo warehouse)
{
//保存
int ret = 0;
UnitWarehouseInfo unit_warehouse = new UnitWarehouseInfo(warehouse.Unit, warehouse);
unit_warehouse.ID = this.NewGuid();
warehouse.ModifyUserID = loggingSession.CurrentUser.User_Id;
warehouse.ModifyUserName = loggingSession.CurrentUser.User_Name;
ISqlMapper sqlMapper = cSqlMapper.Instance(loggingSession.CurrentLoggingManager);
try
{
sqlMapper.BeginTransaction();
//修改仓库
ret = sqlMapper.Update("Pos.Warehouse.Update", warehouse);
//删除仓库与单位的旧关系
sqlMapper.Update("Pos.UnitWarehouse.DeleteByWarehouse", warehouse.ID);
//添加仓库与单位的新关系
sqlMapper.Update("Pos.UnitWarehouse.Insert", unit_warehouse);
sqlMapper.CommitTransaction();
}
catch (Exception ex)
{
sqlMapper.RollBackTransaction();
throw ex;
}
cSqlMapper.Instance(loggingSession.CurrentLoggingManager).Update("Pos.Warehouse.Update", warehouse);
return(ret == 1);
}
/// <summary>
/// 获取满足查询条件的仓库的某页上的所有仓库
/// </summary>
/// <param name="loggingSession">当前登录信息</param>
/// <param name="condition">UnitID:所属单位ID；Code：仓库编码；Name：仓库名称；Contacter：仓库联系人；Tel：仓库电话；Status：仓库状态；</param>
/// <param name="maxRowCount">每页所占行数</param>
/// <param name="startRowIndex">当前页的起始行数</param>
/// <returns>满足条件的终端的列表</returns>
public cPos.Model.Exchange.SelectObjectResultsInfo <WarehouseQueryInfo> SearchWarehouseList(
LoggingSessionInfo loggingSession, Hashtable condition, int maxRowCount, int startRowIndex)
{
condition.Add("StartRow", startRowIndex);
condition.Add("EndRow", startRowIndex + maxRowCount);
condition.Add("MaxRowCount", maxRowCount);
cPos.Model.Exchange.SelectObjectResultsInfo <WarehouseQueryInfo> ret = new cPos.Model.Exchange.SelectObjectResultsInfo <WarehouseQueryInfo>();
ISqlMapper sqlMap = cSqlMapper.Instance(loggingSession.CurrentLoggingManager);
try
{
sqlMap.BeginTransaction();
//插入满足条件的单位进临时表
cPos.Model.Unit.UnitQueryCondition unitQueryCondition = new Model.Unit.UnitQueryCondition();
if (condition.Contains("UnitID"))
{
unitQueryCondition.SuperUnitIDs.Add(condition["UnitID"].ToString());
}
condition.Add("UnitSQL", this.GenInsertUnitTemporaryTableSQL(loggingSession, unitQueryCondition));
//查某页上的通告
ret.Data = sqlMap.QueryForList <WarehouseQueryInfo>("Pos.Warehouse.SelectWarehouseList2", condition);
sqlMap.CommitTransaction();
}
catch (Exception ex)
{
sqlMap.RollBackTransaction();
throw ex;
}
return(ret);
}
public bool InsertWarehouse(LoggingManager loggingManager, WarehouseInfo warehouse)
{
if (string.IsNullOrEmpty(warehouse.ID))
{
warehouse.ID = this.NewGuid();
}
UnitWarehouseInfo unit_warehouse = new UnitWarehouseInfo(warehouse.Unit, warehouse);
unit_warehouse.ID = this.NewGuid();
//保存
ISqlMapper sqlMapper = cSqlMapper.Instance(loggingManager);
try
{
sqlMapper.BeginTransaction();
//添加仓库
sqlMapper.Insert("Pos.Warehouse.Insert", warehouse);
//添加仓库与单位的关系
sqlMapper.Update("Pos.UnitWarehouse.Insert", unit_warehouse);
sqlMapper.CommitTransaction();
}
catch (Exception ex)
{
sqlMapper.RollBackTransaction();
throw ex;
}
return(true);
}
public override bool OnActionExecuted(ActionContext context)
{
try
{
if (!context.Parameters.ContainsKey(Common.MapperKey))
{
return(base.OnActionExecuted(context));
}
ISqlMapper mapper = context.Parameters[Common.MapperKey] as ISqlMapper;
try
{
if (mapper.IsSessionStarted)
{
mapper.CommitTransaction();
}
}
catch (NullReferenceException ex)
{
}
return(base.OnActionExecuted(context));
}
catch (Exception ex)
{
MonitorCache.GetInstance().PushMessage(new CacheMessage {
Message = "在OnExceptionOccurs中报错--Message:" + ex.Message
}, SOAFramework.Library.CacheEnum.FormMonitor);
throw ex;
}
}
public int ExecuteWithTransaction(ISqlMapper sqlMap, System.Collections.Generic.IEnumerable <DBState> batchStatements)
{
int resultRowNum = 0;
try
{
sqlMap.BeginTransaction();
foreach (DBState current in batchStatements)
{
if (current.Type == ESqlType.INSERT)
{
resultRowNum += sqlMap.Update(current.Name, current.Param);
}
else
{
if (current.Type == ESqlType.UPDATE)
{
resultRowNum += sqlMap.Update(current.Name, current.Param);
}
else
{
resultRowNum += sqlMap.Delete(current.Name, current.Param);
}
}
}
sqlMap.CommitTransaction();
}
catch
{
sqlMap.RollBackTransaction();
throw;
}
return(resultRowNum);
}
public bool InsertT_JudgeParamer(IList <T_JudgeParamer> t_JudgeParamerList)
{
bool result = false;
try
{
var session = mapper.BeginTransaction();
foreach (var item in t_JudgeParamerList)
{
JDAO.InsertT_JudgeParamer(item);
}
mapper.CommitTransaction();
result = true;
}
catch (Exception ex) {
}
return(result);
}
/// <summary>
/// Commit data
/// </summary>
public virtual void Commit()
{
if (_finished)
{
throw new InvalidOperationException("Transaction already rolled back or committed");
}
_mapper.CommitTransaction();
_finished = true;
}