public RealDB(string dbName, string dbIP,string saPwd )
{
DataConfiguration config = new SqlDataConfiguration(dbIP, "sa", saPwd, dbName);
this.transactionScopeFactory = new TransactionScopeFactory(config);
this.transactionScopeFactory.Initialize();
base.Initialize(this.transactionScopeFactory);
}
public void Should_New_return_NotNull_transaction()
{
using (var tx = new TransactionScopeFactory().New())
{
tx.ShouldNotBeNull();
}
}
public void Should_throw_when_timeout_exceeded()
{
Should.Throw<TransactionAbortedException>(() =>
{
using (var tx = new TransactionScopeFactory().New(new TransactionScopeOptions(TransactionScopeOption.Required, new TransactionOptions
{
IsolationLevel = IsolationLevel.ReadCommitted,
Timeout = TimeSpan.FromMilliseconds(100)
})))
{
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
tx.Complete();
}
});
}
/// <summary>
///
/// </summary>
/// <param name="ownerKeyBuilder"></param>
/// <param name="data"></param>
public void UpdateCollection(IConnectiveSqlClause ownerKeyBuilder, IEnumerable <T> data)
{
ownerKeyBuilder.NullCheck("ownerKeyBuilder");
data.NullCheck("objs");
Dictionary <string, object> context = new Dictionary <string, object>();
this.BeforeInnerUpdateCollection(data, context);
string sql = VersionStrategyUpdateSqlBuilder <T> .DefaultInstance.ToUpdateCollectionSql(ownerKeyBuilder, this.GetMappingInfo(), data);
using (TransactionScope scope = TransactionScopeFactory.Create())
{
DateTime dt = (DateTime)DbHelper.RunSqlReturnScalar(sql, this.GetConnectionName());
this.AfterInnerUpdateCollection(data, context);
DBTimePointActionContext.Current.TimePoint.IsMinValue(() => DBTimePointActionContext.Current.TimePoint = dt);
scope.Complete();
}
}
public virtual void ApproveCombo(int?sysNo, ComboStatus targetStatus)
{
//Check审核人与创建人不能相同
if (sysNo == null)
{
//throw new BizException("更新失败，参数有误！");
throw new BizException(ResouceManager.GetMessageString("MKT.Combo", "Combo_ArgsError"));
}
ComboInfo oldEntity = _da.Load(sysNo.Value);
//if (oldEntity.Status == ComboStatus.WaitingAudit && oldEntity.CreateUserSysNo == ServiceContext.Current.UserSysNo)
//{
// throw new BizException(string.Format("{0} 创建人与审核人不能相同", oldEntity.Name));
//}
TransactionScopeFactory.TransactionAction(() =>
{
this.UpdateStatus(sysNo, targetStatus);
//更新活动状态
//ObjectFactory<ComboPromotionEngine>.Instance.UpdateComboActivityStatus(sysNo.Value, targetStatus);
});
}
public void Update()
{
XElementFormatter formatter = new XElementFormatter();
formatter.OutputShortType = WorkflowSettings.GetConfig().OutputShortType;
string properties = formatter.Serialize(this).ToString();
string updateSQL = string.Format("UPDATE WF.GLOBAL_PARAMETERS SET [PROPERTIES] = {0} WHERE {1}",
TSqlBuilder.Instance.CheckQuotationMark(properties, true),
GetWhereSqlClauseBuilder(this.Key).ToSqlString(TSqlBuilder.Instance));
using (DbContext context = DbContext.GetContext(WorkflowSettings.GetConfig().ConnectionName))
{
using (TransactionScope scope = TransactionScopeFactory.Create())
{
if (DbHelper.RunSql(updateSQL, WorkflowSettings.GetConfig().ConnectionName) == 0)
{
InsertSqlClauseBuilder iBuilder = new InsertSqlClauseBuilder();
iBuilder.AppendItem("[KEY]", this.Key);
iBuilder.AppendItem("[PROPERTIES]", properties);
iBuilder.AppendTenantCode(typeof(WfGlobalParameters));
string insertSQL = string.Format("INSERT INTO WF.GLOBAL_PARAMETERS {0}",
iBuilder.ToSqlString(TSqlBuilder.Instance));
DbHelper.RunSql(insertSQL, WorkflowSettings.GetConfig().ConnectionName);
}
scope.Complete();
}
}
CacheNotifyData notifyData = new CacheNotifyData(typeof(WfGlobalParametersCache), CalculateCacheKey(this.Key), CacheNotifyType.Invalid);
UdpCacheNotifier.Instance.SendNotifyAsync(notifyData);
MmfCacheNotifier.Instance.SendNotify(notifyData);
}
/// <summary>
/// 根据RoleID加载行信息
/// </summary>
/// <param name="roleID"></param>
/// <param name="role"></param>
/// <param name="definition">列定义</param>
/// <returns></returns>
public SOARolePropertyRowCollection LoadByRoleID(string roleID, IRole role, SOARolePropertyDefinitionCollection definition)
{
roleID.CheckStringIsNullOrEmpty("roleID");
definition.NullCheck("definition");
StringBuilder strB = new StringBuilder();
strB.AppendFormat("SELECT * FROM WF.ROLE_PROPERTIES_ROWS WHERE {0} ORDER BY ROW_NUMBER", roleID.ToRoleIDCriteria());
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
strB.AppendFormat("SELECT * FROM WF.ROLE_PROPERTIES_CELLS WHERE {0} ORDER BY PROPERTIES_ROW_ID", roleID.ToRoleIDCriteria());
SOARolePropertyRowCollection result = new SOARolePropertyRowCollection(role);
using (TransactionScope scope = TransactionScopeFactory.Create(TransactionScopeOption.Suppress))
{
DataSet ds = DbHelper.RunSqlReturnDS(strB.ToString(), GetConnectionName());
Dictionary <int, SOARolePropertyValueCollection> propertyValues = SOARolePropertyValueCollection.LoadAndGroup(ds.Tables[1].DefaultView, definition);
foreach (DataRow row in ds.Tables[0].Rows)
{
SOARolePropertyRow property = new SOARolePropertyRow(role);
ORMapping.DataRowToObject(row, property);
SOARolePropertyValueCollection values = null;
if (propertyValues.TryGetValue(property.RowNumber, out values))
{
property.Values.CopyFrom(values);
}
result.Add(property);
}
}
return(result);
}
public void SaveChanges(string userId)
{
XElementFormatter formatter = new XElementFormatter();
formatter.OutputShortType = false;
string settings = formatter.Serialize(this).ToString();
string updateSQL = string.Format("UPDATE USER_RECENT_DATA SET DATA = {0} WHERE USER_ID = {1} AND CATEGORY = {2}",
TSqlBuilder.Instance.CheckUnicodeQuotationMark(settings),
TSqlBuilder.Instance.CheckUnicodeQuotationMark(userId),
TSqlBuilder.Instance.CheckUnicodeQuotationMark(this.Name));
using (DbContext context = DbContext.GetContext(ConnectionDefine.UserRelativeInfoConnectionName))
{
using (TransactionScope scope = TransactionScopeFactory.Create())
{
if (DbHelper.RunSql(updateSQL, ConnectionDefine.UserRelativeInfoConnectionName) == 0)
{
string insertSQL = string.Format("INSERT INTO USER_RECENT_DATA(USER_ID,CATEGORY, DATA) VALUES({0}, {1}, {2})",
TSqlBuilder.Instance.CheckUnicodeQuotationMark(userId),
TSqlBuilder.Instance.CheckUnicodeQuotationMark(this.Name),
TSqlBuilder.Instance.CheckUnicodeQuotationMark(settings));
DbHelper.RunSql(insertSQL, ConnectionDefine.UserRelativeInfoConnectionName);
}
scope.Complete();
}
}
CacheNotifyData notifyData = new CacheNotifyData(typeof(UserRecentDataCategoryCache), new UserRecentDataCategoryCacheKey(userId, this.Name), CacheNotifyType.Invalid);
UdpCacheNotifier.Instance.SendNotifyAsync(notifyData);
MmfCacheNotifier.Instance.SendNotify(notifyData);
//可有可无，在NLB环境下意义不大。沈峥
UserRecentDataCategoryCache.Instance.Remove(new UserRecentDataCategoryCacheKey(userId, this.Name));
}
/// <summary>
/// 统一修改Acl成员项的状态
/// </summary>
/// <param name="members"></param>
/// <param name="status"></param>
public void UpdateStatus(SCAclContainerOrMemberCollectionBase members, SchemaObjectStatus status)
{
members.NullCheck("members");
ORMappingItemCollection mappings = this.GetMappingInfo();
using (TransactionScope scope = TransactionScopeFactory.Create())
{
foreach (SCAclItem aclItem in members)
{
aclItem.Status = status;
string sql = VersionCommonObjectUpdateStatusSqlBuilder <SCAclItem> .Instance.ToUpdateSql(aclItem, mappings);
DateTime dt = (DateTime)DbHelper.RunSqlReturnScalar(sql, this.GetConnectionName());
SCActionContext.Current.TimePoint.IsMinValue(() => SCActionContext.Current.TimePoint = dt);
}
scope.Complete();
}
}
public static void ProcessPendingActivity(WfPendingActivityInfo pendingActivityInfo)
{
pendingActivityInfo.NullCheck("pendingActivityInfo");
IWfProcess process = GetProcessByActivityID(pendingActivityInfo.ActivityID);
bool needToDeletePendingInfo = true;
if (process != null)
{
IWfActivity currentActivity = process.CurrentActivity;
process.ProcessPendingActivity();
if (currentActivity != null)
{
needToDeletePendingInfo = false;
//已经不存在Pending状态
if (currentActivity.Status != WfActivityStatus.Pending)
{
WfRuntime.ProcessContext.AffectedProcesses.AddOrReplace(process);
using (TransactionScope scope = TransactionScopeFactory.Create())
{
WfRuntime.PersistWorkflows();
WfPendingActivityInfoAdapter.Instance.Delete(pendingActivityInfo);
scope.Complete();
}
}
}
}
if (needToDeletePendingInfo)
{
WfPendingActivityInfoAdapter.Instance.Delete(pendingActivityInfo);
}
}
private static int DoDisplaceUserInRole(SchemaObjectCollection targetUsers, SCUser sourceUser, SCRole role)
{
int result = 0;
var members = PC.Adapters.SCMemberRelationAdapter.Instance.LoadByContainerID(role.ID, DateTime.MinValue);
if (members.ContainsKey(sourceUser.ID) && members[sourceUser.ID].Status == MCS.Library.SOA.DataObjects.Schemas.SchemaProperties.SchemaObjectStatus.Normal)
{
using (System.Transactions.TransactionScope scope = TransactionScopeFactory.Create())
{
bool hasAnyChanges = false;
if (targetUsers.ContainsKey(sourceUser.ID) == false)
{
PC.Executors.SCObjectOperations.InstanceWithoutPermissions.RemoveMemberFromRole(sourceUser, role);
hasAnyChanges = true;
}
foreach (SCUser user in targetUsers)
{
if (user.ID != sourceUser.ID && user.Status == SchemaObjectStatus.Normal)
{
if (members.ContainsKey(user.ID) == false || members[user.ID].Status != SchemaObjectStatus.Normal)
{
PC.Executors.SCObjectOperations.InstanceWithoutPermissions.AddMemberToRole(user, role);
hasAnyChanges = true;
}
}
}
scope.Complete();
if (hasAnyChanges)
{
result = 1;
}
}
}
return(result);
}
/// <summary>
/// 厂商回复的批量发布与拒绝
/// </summary>
/// <param name="item"></param>
public virtual void UpdateProductReviewVendorReplyStatus(ProductReviewReply item)
{
TransactionScopeFactory.TransactionAction(() =>
{
int x = productReviewDA.UpdateProductReviewVendorReplyStatus(item);
switch (item.Status)
{
//发布
case "A":
EventPublisher.Publish <ProductReviewReplyAuditMessage>(new ProductReviewReplyAuditMessage
{
SysNo = item.SysNo.Value,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
break;
//拒绝
case "D":
EventPublisher.Publish <ProductReviewReplyVoidMessage>(new ProductReviewReplyVoidMessage
{
SysNo = item.SysNo.Value,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
break;
}
if (x == 1001)
{
throw new BizException(ResouceManager.GetMessageString("MKT.Comment", "Comment_VendorWithdrawData"));
}
else if (x == 1002)
{
throw new BizException(ResouceManager.GetMessageString("MKT.Comment", "Comment_SubmitFailed"));
}
});
}
public IHttpActionResult Upload(string businessId)
{
Guid ret = Guid.Empty;
if (string.IsNullOrEmpty(businessId) || !Guid.TryParse(businessId, out ret))
{
throw new BizException("参数错误");
}
var tuple = AttachmentOperator.Instance.CommonSetting();
var model = AttachmentOperator.Instance.CommonUpload(businessId, tuple.Item1, tuple.Item2, tuple.Item3);
TaskCollectionData dcd = new TaskCollectionData();
using (TransactionScope scope = TransactionScopeFactory.Create())
{
string errorMessage = "";
var result = TemplateOperator.Instance.ReadTaskData(businessId, tuple.Item2, tuple.Item3, out dcd, out errorMessage);
if (result != 3)
{
return(BizResult(new
{
ResultType = result,
Message = errorMessage
}));
}
AttachmentOperator.Instance.AddModel(model);
scope.Complete();
}
var attachment = new Attachment();
attachment.ConvertEntity(model);
return(BizResult(new
{
ResultType = 3,
Attachment = attachment,
Message = "上传成功",
Sheets = dcd.Sheets.Select(x => new { SheetName = x.SheetName, SheetRowLength = x.Rows.Count }).ToList()
}));
}
public void Update(MaterialContent data, Stream stream)
{
data.NullCheck("data");
stream.NullCheck("stream");
Dictionary <string, object> context = new Dictionary <string, object>();
context["Stream"] = stream;
this.BeforeInnerUpdate(data, context);
using (TransactionScope scope = TransactionScopeFactory.Create())
{
if (this.InnerUpdate(data, context, StringExtension.EmptyStringArray) == 0)
{
this.InnerInsert(data, context, StringExtension.EmptyStringArray);
}
AfterInnerUpdate(data, context);
scope.Complete();
}
}
public Int32 ChangeStatus(String yearMonth, String feeID, Int32 userFlag)
{
FeeInfo feeInfo = this.LoadFeeInfo(yearMonth, feeID);
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
builder.AppendItem(FeeInfoDBConst.FeeID, feeID);
if (!String.IsNullOrEmpty(yearMonth))
{
builder.AppendItem(FeeMonthInfoDBConst.YearMonth, yearMonth);
}
String sql = String.Format("UPDATE {0} SET USE_FLAG={1} WHERE {2} ", String.IsNullOrEmpty(yearMonth) ? FeeInfoDBConst.TableName : ORMapping.GetMappingInfo <FeeMonthInfo>().TableName, userFlag, builder.ToSqlString());
using (TransactionScope scope = TransactionScopeFactory.Create(TransactionScopeOption.Required))
{
int result = _DataHelper.ExecuteSql(sql);
if (!String.IsNullOrEmpty(feeInfo.ParentID))
{
this.UpdateCalculateExp(yearMonth, feeInfo.ParentID);
}
scope.Complete();
return(result);
}
}
public void ExecuteInsertTwoUsersAsyncTest()
{
StringBuilder strB = new StringBuilder();
strB.Append(PrepareUserInsert(UuidHelper.NewUuidString(), "沈峥", "Male"));
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
strB.Append(PrepareUserInsert(UuidHelper.NewUuidString(), "沈嵘", "Male"));
using (DbContext context = DbContext.GetContextAsync(ConnectionName).Result)
{
Database database = DatabaseFactory.Create(context);
using (TransactionScope scope = TransactionScopeFactory.Create())
{
int count = database.ExecuteNonQueryAsync(CommandType.Text, strB.ToString()).Result;
scope.Complete();
Console.WriteLine(count);
Assert.AreEqual(2, count);
}
}
}
/// <summary>
/// 执行队列项的操作，并且移动到已完成中
/// </summary>
/// <param name="pq"></param>
public void DoQueueOperationAndMove(WfPersistQueue pq)
{
using (TransactionScope scope = TransactionScopeFactory.Create())
{
try
{
DoQueueOperation(pq);
}
catch (System.Exception ex)
{
if (ex is TransactionException || ex is DbException)
{
throw;
}
pq.StatusText = ex.ToString();
}
MoveQueueItemToArchived(pq);
scope.Complete();
}
}
/// <summary>
/// 中止
/// </summary>
/// <param name="sysNo"></param>
public virtual void Stop(List <int> sysNoList)
{
string userfullname = ObjectFactory <ICommonBizInteract> .Instance.GetUserFullName(ServiceContext.Current.UserSysNo.ToString(), true);
foreach (int sysNo in sysNoList)
{
GroupBuyingInfo infoTemp = Load(sysNo);
if (infoTemp.Status.Value != GroupBuyingStatus.Active)
{
//throw new BizException(string.Format("团购[{0}]中止失败，只有运行状态的团购才能作废！", sysNo));
throw new BizException(string.Format(ResouceManager.GetMessageString("MKT.Promotion.GroupBuying", "roupBuying_JustRunStop"), sysNo));
}
TransactionScopeFactory.TransactionAction(() =>
{
m_GroupBuyingDA.UpdateGroupBuyingEndDate(sysNo, userfullname);
//促销引擎-更新活动状态 -中止即为完成
//ObjectFactory<GroupBuyingPromotionEngine>.Instance.UpdateGroupBuyingActivityStatus(sysNo, GroupBuyingStatus.Finished);
ExternalDomainBroker.CreateOperationLog(BizLogType.GroupBuyingStop.ToEnumDesc(), BizLogType.GroupBuyingStop, sysNo, infoTemp.CompanyCode);
});
}
}
private static SCRelationObject UpdateRelation(SCOrganization org, SCUser user)
{
SCOrganization root = SCOrganization.GetRoot();
SCRelationObject orgRelation = new SCRelationObject(root, org);
SCRelationObject relation = new SCRelationObject(org, user);
SCActionContext.Current.DoActions(() =>
{
using (TransactionScope scope = TransactionScopeFactory.Create())
{
SchemaObjectAdapter.Instance.Update(org);
SchemaRelationObjectAdapter.Instance.Update(orgRelation);
SchemaObjectAdapter.Instance.Update(user);
SchemaRelationObjectAdapter.Instance.Update(relation);
scope.Complete();
}
});
return(relation);
}
public void Delete(string roleID)
{
roleID.CheckStringIsNullOrEmpty("roleID");
StringBuilder strB = new StringBuilder();
strB.AppendFormat("DELETE WF.ROLE_PROPERTIES_DEFINITIONS WHERE {0}", roleID.ToRoleIDCriteria());
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
strB.AppendFormat("DELETE WF.ROLE_PROPERTIES_ROWS WHERE {0}", roleID.ToRoleIDCriteria());
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
strB.AppendFormat("DELETE WF.ROLE_PROPERTIES_CELLS WHERE {0}", roleID.ToRoleIDCriteria());
using (TransactionScope scope = TransactionScopeFactory.Create())
{
DbHelper.RunSql(strB.ToString(), GetConnectionName());
scope.Complete();
}
}
public void Update(T data)
{
ExceptionHelper.FalseThrow <ArgumentNullException>(data != null, "data");
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration(string.Format("Update({0})", this.GetType().FullName), () =>
{
Dictionary <string, object> context = new Dictionary <string, object>();
BeforeInnerUpdate(data, context);
using (TransactionScope scope = TransactionScopeFactory.Create())
{
if (InnerUpdate(data, context) == 0)
{
InnerInsert(data, context);
}
AfterInnerUpdate(data, context);
scope.Complete();
}
});
}
/// <summary>
/// 修改条件
/// </summary>
/// <param name="ownerID"></param>
/// <param name="type"></param>
/// <param name="conditions"></param>
public void UpdateConditions(string ownerID, string type, SCConditionCollection conditions)
{
ownerID.CheckStringIsNullOrEmpty("ownerID");
ORMappingItemCollection mappings = this.GetMappingInfo();
string sql = this.GetUpdateSql(ownerID, type, conditions);
using (TransactionScope scope = TransactionScopeFactory.Create())
{
DateTime dt = (DateTime)DbHelper.RunSqlReturnScalar(sql, this.GetConnectionName());
SCActionContext.Current.TimePoint.IsMinValue(() => SCActionContext.Current.TimePoint = dt);
//WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
//builder.AppendItem("OwnerID", ownerID);
//builder.AppendItem("Type", type);
//SCSnapshotBasicAdapter.Instance.UpdateCurrentSnapshot(mappings.TableName, mappings.TableName + "_Current", builder);
scope.Complete();
}
}
/// <summary>
/// 修改条件
/// </summary>
/// <param name="ownerID"></param>
/// <param name="type"></param>
/// <param name="conditions"></param>
public void UpdateConditions(string ownerID, string type, SCConditionCollection conditions)
{
ownerID.CheckStringIsNullOrEmpty("ownerID");
ORMappingItemCollection mappings = this.GetMappingInfo();
string sql = this.GetUpdateSql(ownerID, type, conditions);
AUCommon.DoDbAction(() =>
{
using (TransactionScope scope = TransactionScopeFactory.Create())
{
DBTimePointActionContext.Current.TimePoint = (DateTime)DbHelper.RunSqlReturnScalar(sql, this.GetConnectionName());
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
builder.AppendItem("OwnerID", ownerID);
builder.AppendItem("Type", type);
scope.Complete();
}
});
}
/// <summary>
/// 加锁。返回新加的锁，或者原来锁的状态。成功与否，检查SCCheckLockResult的Available属性
/// </summary>
/// <param name="lockData"></param>
/// <returns></returns>
public SCCheckLockResult AddLock(SCLock lockData)
{
SCCheckLockResult result = null;
lockData.LockTime = DateTime.MinValue;
using (TransactionScope scope = TransactionScopeFactory.Create())
{
//插入是否成功，判断锁是否已经存在
SCLock lockInDB = Insert(lockData);
if (lockInDB == null)
{
//更新是否成功，如果不成功，表示锁被占用。
bool updated = false;
lockInDB = Update(lockData, false, out updated);
if (updated == false)
{
result = BuildNotAvailableResult(lockInDB);
}
else
{
result = BuildAvailableResult(lockInDB, true);
}
}
else
{
result = BuildAvailableResult(lockInDB, false);
}
scope.Complete();
}
return(result);
}
public void DeleteVersion(string applicationName, int version)
{
if (!Auth.AllowDeleteVersion(applicationName))
{
throw new SettingsAuthorizationException(AuthorizationScope.Version, AuthorizationLevel.Delete, applicationName, Auth.CurrentIdentity.Id);
}
var application = GetApplicationsData(applicationName).SingleOrDefault();
if (application == null)
{
throw new SettingsNotFoundException(Constants.ERROR_APPLICATION_UNKNOWN);
}
var data = GetVersionData(application).SingleOrDefault(v => v.Version == version);
if (data == null)
{
throw new SettingsNotFoundException(Constants.ERROR_VERION_UNKNOWN);
}
if (data.Version == 1)
{
throw new SettingsAuthorizationException(AuthorizationScope.Version, AuthorizationLevel.Delete, applicationName, Auth.CurrentIdentity.Id);
}
using (TransactionScope scope = TransactionScopeFactory.CreateReaduncommited())
{
var settings = Store.Context.Settings.Where(s => s.VersionId == data.Id);
Store.Context.Settings.RemoveRange(settings);
Store.Context.SaveChanges();
Store.Context.Versions.Remove(data);
Store.Context.SaveChanges();
scope.Complete();
}
}
/// <summary>
/// 创建OptionalAccessories
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public virtual int?CreateOptionalAccessories(OptionalAccessoriesInfo info)
{
List <string> errorList = CheckBasicIsPass(info);
if (errorList.Count > 0)
{
throw new BizException(errorList.Join("\r\n"));
}
errorList = CheckOptionalAccessoriesItemIsPass(info, false);
if (errorList.Count > 0)
{
throw new BizException(errorList.Join("\r\n"));
}
if (info.Status == null)
{
info.Status = ComboStatus.Deactive;
}
TransactionScopeFactory.TransactionAction(() =>
{
info.SysNo = _da.CreateMaster(info);
foreach (OptionalAccessoriesItem item in info.Items)
{
item.OptionalAccessoriesSysNo = info.SysNo;
_da.AddOptionalAccessoriesItem(item);
}
//将数据保存到PromotionEngine配置库中
//_oaPromotionEngine.SaveActivity(info);
});
ExternalDomainBroker.CreateOperationLog(BizLogType.OptionalAccessories_Create.ToEnumDesc(), BizLogType.OptionalAccessories_Create, info.SysNo.Value, info.CompanyCode);
return(info.SysNo);
}
/// <summary>
/// 保存文件的版本
/// </summary>
/// <param name="materials">已经做好的文件版本信息</param>
/// <param name="rootPathName">根文件夹路径配置名称</param>
public void SaveOtherVersion(MaterialList materials, string rootPathName)
{
StringBuilder strB = new StringBuilder(256);
foreach (Material material in materials)
{
if (strB.Length > 0)
{
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
}
strB.Append(ORMapping.GetInsertSql <Material>(material, TSqlBuilder.Instance));
}
if (strB.Length != 0)
{
using (TransactionScope scope = TransactionScopeFactory.Create(TransactionScopeOption.Required))
{
DbHelper.RunSql(strB.ToString(), GetConnectionName());
DoFilesCopy(materials, rootPathName, rootPathName, false);
scope.Complete();
}
}
}
public int Delete(string[] ids)
{
InSqlClauseBuilder builder = new InSqlClauseBuilder("JOB_ID");
builder.AppendItem(ids);
int result = 0;
if (builder.Count > 0)
{
string sql = string.Format("{0} {1}",
DELETE_JOB_START_WORKFLOW_SQL_CLAUSE,
builder.ToSqlString(TSqlBuilder.Instance));
using (TransactionScope tran = TransactionScopeFactory.Create())
{
JobBaseAdapter.Instance.Delete(ids);
result = DbHelper.RunSqlWithTransaction(sql, GetConnectionName());
tran.Complete();
}
}
return(result);
}
public void Update(string roleID, SOARolePropertyRowCollection rows)
{
roleID.CheckStringIsNullOrEmpty("roleID");
rows.NullCheck("rows");
StringBuilder strB = new StringBuilder(1024);
strB.AppendFormat("DELETE WF.ROLE_PROPERTIES_ROWS WHERE {0}", roleID.ToRoleIDCriteria());
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
strB.AppendFormat("DELETE WF.ROLE_PROPERTIES_CELLS WHERE {0}", roleID.ToRoleIDCriteria());
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
strB.AppendFormat("DELETE WF.ROLE_PROPERTIES_USER_CONTAINERS WHERE {0}", roleID.ToRoleIDCriteria());
PrepareRowsSql(roleID, rows, strB);
SOARolePropertyRowUsersCollection rowsUsers = rows.GenerateRowsUsersDirectly();
SOARolePropertyRowRolesCollection rowsRoles = rows.GenerateRowsRolesDirectly();
PrepareUserContainers(roleID, rowsUsers, strB);
PrepareRoleContainers(roleID, rowsRoles, strB);
using (TransactionScope scope = TransactionScopeFactory.Create())
{
DbHelper.RunSql(strB.ToString(), GetConnectionName());
scope.Complete();
}
CacheNotifyData notifyData = new CacheNotifyData(typeof(SOARolePropertiesCache), roleID.ToRoleIDCacheKey(), CacheNotifyType.Invalid);
UdpCacheNotifier.Instance.SendNotifyAsync(notifyData);
MmfCacheNotifier.Instance.SendNotify(notifyData);
}
private void InsertGroupUsers(WfGroupUserCollection groupUsers)
{
using (TransactionScope scope = TransactionScopeFactory.Create())
{
foreach (WfGroupUser groupUser in groupUsers)
{
string ingoreUserId = "UserID";
string sql = ORMapping.GetInsertSql(groupUser, TSqlBuilder.Instance, ingoreUserId);
try
{
DbHelper.RunSql(sql, GetConnectionName());
}
catch (System.Data.SqlClient.SqlException ex)
{
if (ex.ErrorCode != 2627)
{
throw;
}
}
}
scope.Complete();
}
}
/// <summary>
/// 向日志表中插入数据
/// </summary>
/// <param name="userLogonName">用户登录名</param>
/// <param name="strAppname">应用程序英文标识</param>
/// <param name="strHostIP">客户端IP</param>
/// <param name="strHostName">客户端机器名</param>
/// <param name="strUrl">用户访问URL</param>
/// <param name="strGoalID">跟踪操作的英文标识</param>
/// <param name="strGoalName">跟踪操作的中文标识</param>
/// <param name="strGoalDisplayName">跟踪操作的中文解释</param>
/// <param name="strOpType">操作类型英文标识</param>
/// <param name="strExplain">操作的详细说明</param>
/// <param name="strOriginalData">操作的原始数据</param>
/// <param name="bOpSucceed">该操作是否成功</param>
public static void InsertUserLog(string userLogonName,
string strAppname,
string strHostIP,
string strHostName,
string strUrl,
string strGoalID,
string strGoalName,
string strGoalDisplayName,
string strOpType,
string strExplain,
string strOriginalData,
bool bOpSucceed)
{
string strSql = GetInsertUserSql2(userLogonName, strAppname, strHostIP, strHostName, strUrl, strGoalID, strGoalName, strGoalDisplayName, strOpType, strExplain, strOriginalData, bOpSucceed);
if (false == string.IsNullOrEmpty(strSql))
{
using (TransactionScope scope = TransactionScopeFactory.Create())
{
CommonDefine.ExecuteNonQuery(strSql);
scope.Complete();
}
}
}
public void Update(string roleID, SOARolePropertyDefinitionCollection properties)
{
roleID.CheckStringIsNullOrEmpty("roleID");
properties.NullCheck("properties");
StringBuilder strB = new StringBuilder();
strB.AppendFormat("DELETE WF.ROLE_PROPERTIES_DEFINITIONS WHERE {0}", roleID.ToRoleIDCriteria());
foreach (SOARolePropertyDefinition property in properties)
{
if (strB.Length > 0)
{
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
}
property.RoleID = roleID;
strB.AppendFormat(ORMapping.GetInsertSql(property, TSqlBuilder.Instance));
}
using (TransactionScope scope = TransactionScopeFactory.Create())
{
DbHelper.RunSql(strB.ToString(), GetConnectionName());
scope.Complete();
}
string cacheKey = roleID.ToRoleIDCacheKey();
CacheNotifyData notifyData1 = new CacheNotifyData(typeof(SOARolePropertiesDefinitionCache), cacheKey, CacheNotifyType.Invalid);
CacheNotifyData notifyData2 = new CacheNotifyData(typeof(SOARolePropertiesCache), cacheKey, CacheNotifyType.Invalid);
UdpCacheNotifier.Instance.SendNotifyAsync(notifyData1, notifyData2);
MmfCacheNotifier.Instance.SendNotify(notifyData1, notifyData2);
}
public void Execute(IJobExecutionContext context)
{
LogMgnt.Instance["StartTaskService"].Info("------------计划任务发起服务开始运行-------------");
try
{
var pendingList = TemplateConfigInstancePlanOperator.Instance.GetPendingList(10);
if (pendingList != null)
{
pendingList.ForEach(x =>
{
using (TransactionScope scope = TransactionScopeFactory.Create())
{
//创建任务
var targetTemplateConfigInstance =
TemplateConfigInstanceOperator.Instance.GetModel(x.TemplateConfigInstanceID);
var dcuList = DataCollectUserOperator.Instance.GetList(targetTemplateConfigInstance.ID);
var taskUserList = dcuList.Select(dcu =>
{
TaskUser taskUser = new TaskUser
{
UserName = dcu.UserName,
EmployeeCode = dcu.EmployeeCode,
EmployeeName = dcu.EmployeeName,
OrgID = dcu.OrgID,
OrgName = dcu.OrgName,
UnitID = dcu.UnitID,
UnitName = dcu.UnitName
};
return(taskUser);
}).ToList();
if (targetTemplateConfigInstance == null)
{
x.Status = -3;
TemplateConfigInstancePlanOperator.Instance.UpdateModel(x);
return;
}
//发起任务
targetTemplateConfigInstance.CreateDate = DateTime.Now;
targetTemplateConfigInstance.CircleType = 1;
targetTemplateConfigInstance.PlanBeginDate = null;
targetTemplateConfigInstance.PlanEndDate = null;
targetTemplateConfigInstance.TaskType = 3;
targetTemplateConfigInstance.ID = Guid.NewGuid().ToString();
targetTemplateConfigInstance.TemplateConfigInstanceName += $"-{x.TimeNode:yyyyMMdd}";
targetTemplateConfigInstance.ProcessStatus = 0;
targetTemplateConfigInstance.NotifyStatus = false;
TemplateConfigInstanceOperator.Instance.AddModel(targetTemplateConfigInstance);
TemplateConfigInstanceOperator.Instance.UpdateTaskInfo(targetTemplateConfigInstance, taskUserList, false);
//更新任务计划发起状态
x.Status = 2;
x.SubTemplateConfigInstanceID = Guid.Parse(targetTemplateConfigInstance.ID);
TemplateConfigInstancePlanOperator.Instance.UpdateModel(x);
scope.Complete();
}
});
}
}
catch (Exception ex)
{
LogMgnt.Instance["StartTaskService"].Error("任务执行异常，错误信息{0}，错误堆栈{1}", ex.Message, ex.StackTrace);
}
LogMgnt.Instance["StartTaskService"].Info("------------计划任务发起服务结束运行-------------");
}
public void Initialize(TransactionScopeFactory fac)
{
this.transactionScopeFactory = fac;
}
public SqliteChatRecordPersister(string sqlitePath)
{
try
{
bool isNew = !File.Exists(sqlitePath);
//2014.11.27
string dirName = Path.GetDirectoryName(sqlitePath);
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
//初始化Sqlite数据库
DataConfiguration config = new SqliteDataConfiguration(sqlitePath);
TransactionScopeFactory transactionScopeFactory = new TransactionScopeFactory(config);
transactionScopeFactory.Initialize();
if (isNew)
{
string sql = "CREATE TABLE ChatMessageRecord (AutoID INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, SpeakerID VARCHAR( 0, 20 ) NOT NULL, AudienceID VARCHAR( 0, 20 ) NOT NULL, IsGroupChat BOOLEAN NOT NULL, Content BLOB NOT NULL, OccureTime DATETIME NOT NULL ); "
+ "CREATE INDEX idx_ChatMessageRecord ON ChatMessageRecord ( SpeakerID, AudienceID, OccureTime DESC );"
+ "CREATE INDEX idx2_ChatMessageRecord ON ChatMessageRecord ( AudienceID, IsGroupChat, OccureTime );";
using (TransactionScope scope = transactionScopeFactory.NewTransactionScope())
{
IRelationAccesser accesser = scope.NewRelationAccesser();
accesser.DoCommand(sql);
scope.Commit();
}
}
base.Initialize(transactionScopeFactory);
}
catch { }
}
