/// <summary>
/// 保持SignInInfo信息
/// </summary>
/// <param name="signInInfo">SignInInfo信息</param>
/// <remarks>
/// <code source="..\Framework\TestProjects\DeluxeWorks.Library.Passport.Test\DataObjectsTest.cs" region="SignInInfoPersistTest" lang="cs" title="保存SignInInfo对象" />
/// </remarks>
public void SaveSignInInfo(ISignInInfo signInInfo)
{
ORMappingItemCollection mapping = LoadMappingFromResource("MCS.Library.Passport.DataObjects.SignInInfoMapping.xml", typeof(ISignInInfo));
string sql = string.Format("UPDATE PASSPORT_SIGNIN_INFO SET {0} WHERE {1}",
ORMapping.GetUpdateSqlClauseBuilder(signInInfo, mapping).ToSqlString(TSqlBuilder.Instance),
ORMapping.GetWhereSqlClauseBuilderByPrimaryKey(signInInfo, mapping).ToSqlString(TSqlBuilder.Instance));
using (TransactionScope scope = TransactionScopeFactory.Create())
{
using (DbContext context = DbContext.GetContext(DataAdapter.DBConnectionName))
{
Database db = DatabaseFactory.Create(DataAdapter.DBConnectionName);
if (db.ExecuteNonQuery(CommandType.Text, sql) == 0)
{
sql = string.Format("INSERT INTO PASSPORT_SIGNIN_INFO {0}",
ORMapping.GetInsertSqlClauseBuilder(signInInfo, mapping).ToSqlString(TSqlBuilder.Instance));
db.ExecuteNonQuery(CommandType.Text, sql);
}
}
scope.Complete();
}
}
/// <summary>
/// 按照ResourceID来更新数据
/// </summary>
/// <param name="resourceID"></param>
/// <param name="assignees"></param>
public virtual void Update(string resourceID, TTaskAssigneeCollection assignees)
{
resourceID.CheckStringIsNullOrEmpty("resourceID");
assignees.NullCheck("assignees");
StringBuilder strB = new StringBuilder();
ORMappingItemCollection mappings = GetMappingInfo(new Dictionary <string, object>());
WhereSqlClauseBuilder wBuilder = new WhereSqlClauseBuilder();
wBuilder.AppendItem("RESOURCE_ID", resourceID);
wBuilder.AppendTenantCode();
strB.AppendFormat("DELETE {0} WHERE {1}",
mappings.TableName,
wBuilder.ToSqlString(TSqlBuilder.Instance));
foreach (TTaskAssignee assignee in assignees)
{
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(assignee, mappings);
strB.AppendFormat("INSERT INTO {0}{1}",
mappings.TableName,
builder.ToSqlString(TSqlBuilder.Instance));
}
DbHelper.RunSqlWithTransaction(strB.ToString(), GetConnectionName());
}
private static string PrepareRowSql(string roleID, SOARolePropertyRow row)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(row);
builder.AppendItem("ROLE_ID", roleID);
return("INSERT INTO WF.ROLE_PROPERTIES_ROWS" + builder.ToSqlString(TSqlBuilder.Instance));
}
private static string GetUserTaskInsertSql(UserTask task, ORMappingItemCollection mapping, params string[] ignoreProperties)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(task, mapping, ignoreProperties);
builder.AppendTenantCode();
return(string.Format("INSERT INTO {0} {1}", mapping.TableName, builder.ToSqlString(TSqlBuilder.Instance)));
}
private static string PrepareInsertPropertyDefineSql(SchemaDefine data, SchemaPropertyDefine pd)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(pd);
builder.AppendItem("SchemaName", data.Name);
return(string.Format("INSERT INTO {0}{1}", ORMapping.GetMappingInfo(pd.GetType()).TableName, builder.ToSqlString(TSqlBuilder.Instance)));
}
protected override string GetInsertSql(WfProcessDescriptorDimension data, ORMappingItemCollection mappings, Dictionary <string, object> context)
{
InsertSqlClauseBuilder iBuilder = ORMapping.GetInsertSqlClauseBuilder(data, mappings);
iBuilder.AppendTenantCode();
return(string.Format("INSERT INTO {0} {1}", mappings.TableName, iBuilder.ToSqlString(TSqlBuilder.Instance)));
}
private static string PrepareInsertSql(UserAndContainerSnapshot obj, ORMappingItemCollection mapping)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(obj);
builder.AppendItem("VersionStartTime", "@currentTime", "=", true);
builder.AppendItem("VersionEndTime", SCConnectionDefine.MaxVersionEndTime);
return(string.Format("INSERT INTO {0}{1}", mapping.TableName, builder.ToSqlString(TSqlBuilder.Instance)));
}
private static string PrepareValueSql(string roleID, SOARolePropertyRow row, SOARolePropertyValue propValue)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(propValue);
builder.AppendItem("ROLE_ID", roleID);
builder.AppendItem("PROPERTIES_ROW_ID", row.RowNumber);
builder.AppendItem("PROPERTY_NAME", propValue.Column.Name);
return("INSERT INTO WF.ROLE_PROPERTIES_CELLS" + builder.ToSqlString(TSqlBuilder.Instance));
}
protected override string GetInsertSql(WfDelegation data, ORMappingItemCollection mappings, Dictionary <string, object> context, string[] ignoreProperties)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(data, mappings, "ApplicationName", "ProgramName");
builder.AppendItem("APPLICATION_NAME", data.ApplicationName.IsNotEmpty() ? data.ApplicationName : string.Empty);
builder.AppendItem("PROGRAM_NAME", data.ProgramName.IsNotEmpty() ? data.ProgramName : string.Empty);
return(string.Format("INSERT INTO {0} {1}",
mappings.TableName,
builder.ToSqlString(TSqlBuilder.Instance)));
}
private static void WriteInsertAttachmentSql(TextWriter writer, EmailAttachment attachment, string messageID, int index)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(attachment);
builder.AppendItem("MESSAGE_ID", messageID);
builder.AppendItem("SORT_ID", index);
string sql = string.Format("INSERT INTO MSG.EMAIL_ATTACHMENTS{0}",
builder.ToSqlString(TSqlBuilder.Instance));
writer.WriteLine(sql);
}
private void InnerInsertWithStream(MaterialContent data, Stream stream, Dictionary <string, object> context)
{
ORMappingItemCollection mappings = GetMappingInfo(context);
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(data, "ContentData");
builder.AppendItem("CONTENT_DATA", stream);
string sql = string.Format("INSERT INTO {0}{1} ",
mappings.TableName,
builder.ToSqlString(TSqlBuilder.Instance));
DbHelper.RunSql(sql, GetConnectionName());
}
/// <summary>
/// 颁发认证码
/// </summary>
/// <param name="authenticationType"></param>
/// <param name="codeLength"></param>
/// <returns></returns>
public AuthenticationCode IssueCode(string authenticationType, int codeLength)
{
AuthenticationCode result = AuthenticationCode.Create(authenticationType, codeLength);
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(result);
builder.AppendItem("EXPIRE_TIME", string.Format("DATEADD(second, {0}, GETDATE())", 1800), "=", true);
string sql = string.Format("INSERT INTO {0} {1}", this.GetMappingInfo().TableName, builder.ToSqlString(TSqlBuilder.Instance));
ExecuteNonQuery(sql);
return(result);
}
protected virtual InsertSqlClauseBuilder PrepareInsertSqlBuilder(T obj, ORMappingItemCollection mapping)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(obj, mapping);
//string vsFieldName = GetPropertyFieldName("VersionStartTime", mapping);
//string veFieldName = GetPropertyFieldName("VersionEndTime", mapping);
//builder.Remove(b => ((SqlClauseBuilderItemIUW)b).DataField == vsFieldName);
//builder.Remove(b => ((SqlClauseBuilderItemIUW)b).DataField == veFieldName);
//builder.AppendItem(vsFieldName, "@currentTime", "=", true);
//builder.AppendItem(veFieldName, ConnectionDefine.MaxVersionEndTime);
return(builder);
}
protected override string GetInsertSql(TxProcess data, ORMappingItemCollection mappings, Dictionary <string, object> context, string[] ignoreProperties)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(data, mappings, ignoreProperties);
string serilizedProcess = context.GetValue("SerilizedProcess", string.Empty);
if (serilizedProcess.IsNullOrEmpty())
{
serilizedProcess = GetSerilizedProcess(data);
}
builder.AppendItem("DATA", serilizedProcess);
return(string.Format("INSERT INTO {0} {1}", this.GetTableName(), builder.ToSqlString(TSqlBuilder.Instance)));
}
/// <summary>
/// 生成带VersionStartTime和VersionEndTime的InsertBuilder
/// </summary>
/// <param name="obj"></param>
/// <param name="mapping"></param>
/// <param name="ignoreProperties">需要忽略的属性</param>
/// <returns></returns>
public virtual InsertSqlClauseBuilder PrepareInsertSqlBuilder(T obj, ORMappingItemCollection mapping, string[] ignoreProperties)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(obj, mapping, ignoreProperties);
string startTimeFieldName = GetPropertyFieldName("VersionStartTime", mapping);
string endTimeFieldName = GetPropertyFieldName("VersionEndTime", mapping);
builder.Remove(b => ((SqlClauseBuilderItemIUW)b).DataField == startTimeFieldName);
builder.Remove(b => ((SqlClauseBuilderItemIUW)b).DataField == endTimeFieldName);
builder.AppendItem(startTimeFieldName, DBTimePointActionContext.CurrentTimeTSqlVarName, "=", true);
builder.AppendItem(endTimeFieldName, DBTimePointActionContext.MaxVersionEndTime);
return(builder);
}
/// <summary>
/// 更新给定的数据实体集合
/// </summary>
/// <param name="whereAction">where委托，用来限定需要设置VersionEndTime的数据</param>
/// <param name="data">数据实体集合，用来新增的数据集合</param>
/// <param name="versionTime">版本时间</param>
/// <returns>更新数据使用时间</returns>
public DateTime UpdateCurrentData(Action <WhereSqlClauseBuilder> whereAction, TCollection data, DateTime versionTime)
{
StringBuilder strB = new StringBuilder();
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
if (whereAction != null)
{
whereAction(builder);
}
builder.AppendItem("VersionEndTime", DBNull.Value, "IS");
if (versionTime != DateTime.MinValue)
{
strB.AppendFormat(@"DECLARE @CURRENTTIME DATETIME
SET @CURRENTTIME = {0}
UPDATE {1} SET VersionEndTime = @CURRENTTIME WHERE {2}",
TSqlBuilder.Instance.FormatDateTime(versionTime),
GetMappingInfo(new Dictionary <string, object>()).TableName,
builder.ToSqlString(TSqlBuilder.Instance));
}
else
{
strB.AppendFormat(@"DECLARE @CURRENTTIME DATETIME
SET @CURRENTTIME =GETDATE()
UPDATE {0} SET VersionEndTime = @CURRENTTIME WHERE {1}",
GetMappingInfo(new Dictionary <string, object>()).TableName,
builder.ToSqlString(TSqlBuilder.Instance));
}
ORMappingItemCollection mappings = GetMappingInfo(new Dictionary <string, object>());
foreach (var item in data)
{
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
InsertSqlClauseBuilder insertBuilder = ORMapping.GetInsertSqlClauseBuilder(item, mappings, "VersionStartTime");
insertBuilder.AppendItem("VersionStartTime", "@CURRENTTIME", null, true);
strB.Append(string.Format(" INSERT INTO {0} {1};", mappings.TableName,
insertBuilder.ToSqlString(TSqlBuilder.Instance))
);
}
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
strB.Append("SELECT @CURRENTTIME");
return((DateTime)DbHelper.RunSqlReturnScalar(strB.ToString(), GetConnectionName()));
}
private static void WriteInsertAddressSql(TextWriter writer, EmailAddress address, string messageID, string className, int index)
{
if (address != null)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(address);
builder.AppendItem("MESSAGE_ID", messageID);
builder.AppendItem("SORT_ID", index);
builder.AppendItem("CLASS", className);
string sql = string.Format("INSERT INTO MSG.EMAIL_ADDRESSES{0}",
builder.ToSqlString(TSqlBuilder.Instance));
writer.WriteLine(sql);
}
}
public void LocalTimeToUtcTest()
{
TimeZoneContext.Current.CurrentTimeZone = TimeZoneInfo.CreateCustomTimeZone("TimeZoneInfoContext", TimeSpan.FromMinutes(480), "TimeZoneInfoContext", "TimeZoneInfoContext");
TestObject data = new TestObject();
data.LocalTime = DateTime.Now;
data.UtcTime = data.LocalTime;
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(data);
SqlClauseBuilderItemIUW itemLocalTime = (SqlClauseBuilderItemIUW)builder.Find(item => ((SqlClauseBuilderItemIUW)item).DataField == "LOCAL_TIME");
SqlClauseBuilderItemIUW itemUtcTime = (SqlClauseBuilderItemIUW)builder.Find(item => ((SqlClauseBuilderItemIUW)item).DataField == "UTC_TIME");
Console.Write("Local Time: {0}, Utc Time: {1}", itemLocalTime.Data, itemUtcTime.Data);
Assert.AreNotEqual(itemLocalTime.Data, itemUtcTime.Data);
}
private static void WriteEmailMessageBodySql(TextWriter writer, EmailMessage message, string tableName, bool generateSentTime)
{
ORMappingItemCollection mappingInfo = GetMappingInfo();
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(message, mappingInfo);
builder.AppendItem("BODY_ENCODING", message.BodyEncoding.ToDescription());
builder.AppendItem("HEADERS_ENCODING", message.HeadersEncoding.ToDescription());
builder.AppendItem("SUBJECT_ENCODING", message.SubjectEncoding.ToDescription());
if (generateSentTime)
{
builder.AppendItem("SENT_TIME", "GETDATE()", "=", true);
builder.AppendItem("SORT_ID", message.SortID);
}
string sql = string.Format("INSERT INTO {0}{1}",
tableName, builder.ToSqlString(TSqlBuilder.Instance));
writer.WriteLine(sql);
}
public void InsertWithContent(MaterialList materials)
{
materials.NullCheck("materials");
StringBuilder strB = new StringBuilder();
ORMappingItemCollection mappings = ORMapping.GetMappingInfo(typeof(Material));
foreach (Material m in materials)
{
if (strB.Length > 0)
{
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
}
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(m, mappings, "CreateDateTime");
builder.AppendItem("CREATE_DATETIME", m.CreateDateTime);
strB.AppendFormat("INSERT INTO {0}{1}", mappings.TableName, builder.ToSqlString(TSqlBuilder.Instance));
}
if (strB.Length > 0)
{
using (TransactionScope scope = TransactionScopeFactory.Create())
{
DbHelper.RunSql(strB.ToString(), GetConnectionName());
foreach (Material m in materials)
{
m.Content.RelativeID = m.ResourceID;
MaterialFileOeprationInfo fileOp = new MaterialFileOeprationInfo(m, FileOperation.Update);
DoFileOperation(MaterialAdapter.DefaultUploadPathName, fileOp, m.Content);
}
scope.Complete();
}
}
}
/// <summary>
/// 保持ITicket信息
/// </summary>
/// <param name="ticket">ITicket信息</param>
/// <param name="signInUrl">登录Url</param>
/// <param name="logOffCBUrl">注销的Url</param>
/// <remarks>
/// <code source="..\Framework\TestProjects\DeluxeWorks.Library.Passport.Test\DataObjectsTest.cs" region="TicketPersistTest" lang="cs" title="保存Ticket对象" />
/// </remarks>
public void SaveTicket(ITicket ticket, Uri signInUrl, Uri logOffCBUrl)
{
ORMappingItemCollection mapping = LoadMappingFromResource("MCS.Library.Passport.DataObjects.TicketInfoMapping.xml", typeof(ITicket));
WhereSqlClauseBuilder whereBuilder =
ORMapping.GetWhereSqlClauseBuilderByPrimaryKey(ticket, mapping);
whereBuilder.AppendItem("SIGNIN_ID", ticket.SignInInfo.SignInSessionID);
UpdateSqlClauseBuilder updateBuilder = ORMapping.GetUpdateSqlClauseBuilder(ticket, mapping);
updateBuilder.AppendItem("APP_SIGNIN_URL", signInUrl.ToString());
updateBuilder.AppendItem("APP_LOGOFF_URL", logOffCBUrl.ToString());
string sql = string.Format("UPDATE PASSPORT_TICKET SET {0} WHERE {1}",
updateBuilder.ToSqlString(TSqlBuilder.Instance),
whereBuilder.ToSqlString(TSqlBuilder.Instance));
using (TransactionScope scope = TransactionScopeFactory.Create())
{
using (DbContext context = DbContext.GetContext(DataAdapter.DBConnectionName))
{
Database db = DatabaseFactory.Create(DataAdapter.DBConnectionName);
if (db.ExecuteNonQuery(CommandType.Text, sql) == 0)
{
InsertSqlClauseBuilder insertBuilder = ORMapping.GetInsertSqlClauseBuilder(ticket, mapping);
insertBuilder.AppendItem("SIGNIN_ID", ticket.SignInInfo.SignInSessionID);
insertBuilder.AppendItem("APP_SIGNIN_URL", signInUrl.ToString());
insertBuilder.AppendItem("APP_LOGOFF_URL", logOffCBUrl.ToString());
sql = string.Format("INSERT INTO PASSPORT_TICKET {0}",
insertBuilder.ToSqlString(TSqlBuilder.Instance));
db.ExecuteNonQuery(CommandType.Text, sql);
}
}
scope.Complete();
}
}
public void MoveQueueItemToArchived(WfPersistQueue pq)
{
pq.NullCheck("pq");
ORMappingItemCollection mappingInfo = ORMapping.GetMappingInfo(typeof(WfPersistQueue));
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(pq, mappingInfo);
builder.AppendItem("SORT_ID", pq.SortID);
builder.AppendItem("PROCESS_TIME", "GETUTCDATE()", "=", true);
StringBuilder sql = new StringBuilder();
sql.AppendFormat("DELETE {0} WHERE SORT_ID = {1}", "WF.PERSIST_QUEUE_ARCHIEVED", pq.SortID);
sql.Append(TSqlBuilder.Instance.DBStatementSeperator);
sql.AppendFormat("INSERT INTO {0}{1}", "WF.PERSIST_QUEUE_ARCHIEVED", builder.ToSqlString(TSqlBuilder.Instance));
sql.Append(TSqlBuilder.Instance.DBStatementSeperator);
sql.AppendFormat("DELETE {0} WHERE PROCESS_ID = {1}", mappingInfo.TableName, TSqlBuilder.Instance.CheckUnicodeQuotationMark(pq.ProcessID));
DbHelper.RunSqlWithTransaction(sql.ToString(), GetConnectionName());
}
private string GetUpdateSql(string ownerID, string type, SCConditionCollection conditions)
{
if (type.IsNullOrEmpty())
{
type = "Default";
}
conditions.ForEach(c => { c.OwnerID = ownerID; c.Type = type; });
return(VersionStrategyUpdateSqlHelper.ConstructUpdateSql(null, (strB, context) =>
{
ConnectiveSqlClauseCollection connectiveBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder();
WhereSqlClauseBuilder keyBuilder = new WhereSqlClauseBuilder();
keyBuilder.AppendItem("OwnerID", ownerID);
keyBuilder.AppendItem("type", type);
connectiveBuilder.Add(keyBuilder);
strB.AppendFormat("UPDATE {0} SET VersionEndTime = {1} WHERE {2}",
this.GetMappingInfo().TableName, "@currentTime", connectiveBuilder.ToSqlString(TSqlBuilder.Instance));
for (int i = 0; i < conditions.Count; i++)
{
SCCondition condition = conditions[i];
condition.SortID = i;
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
condition.VersionEndTime = ConnectionDefine.MaxVersionEndTime;
condition.Type = type;
InsertSqlClauseBuilder insertBuilder = ORMapping.GetInsertSqlClauseBuilder(condition, this.GetMappingInfo(), "VersionStartTime");
insertBuilder.AppendItem("VersionStartTime", "@currentTime", "=", true);
strB.AppendFormat("INSERT INTO {0}{1}", this.GetMappingInfo().TableName, insertBuilder.ToSqlString(TSqlBuilder.Instance));
}
}));
}
public void GetInnerUpdateCurrentDataSql(T data, DateTime versionTime, StringBuilder sqlbuilder)
{
ORMappingItemCollection mappings = GetMappingInfo(new Dictionary <string, object>());
WhereSqlClauseBuilder whereBuilder = ORMapping.GetWhereSqlClauseBuilderByPrimaryKey(data, mappings,
"VersionStartTime");
whereBuilder.AppendItem("VersionEndTime", DBNull.Value, "IS");
if (versionTime == DateTime.MinValue)
{
versionTime = SNTPClient.AdjustedTime;
}
if (sqlbuilder.ToString().Contains("DECLARE @CURRENTTIME DATETIME") == false)
{
sqlbuilder.Append("DECLARE @CURRENTTIME DATETIME");
sqlbuilder.Append(TSqlBuilder.Instance.DBStatementSeperator);
}
sqlbuilder.AppendFormat(
@" SET @CURRENTTIME = {0} {3} UPDATE {1} SET VersionEndTime = @CURRENTTIME WHERE {2}; ",
TSqlBuilder.Instance.FormatDateTime(versionTime),
mappings.TableName,
whereBuilder.ToSqlString(TSqlBuilder.Instance),
TSqlBuilder.Instance.DBStatementSeperator
);
InsertSqlClauseBuilder insertBuilder = ORMapping.GetInsertSqlClauseBuilder(data, mappings, "VersionStartTime");
insertBuilder.AppendItem("VersionStartTime", "@CURRENTTIME", "=", true);
string insertSql =
string.Format("INSERT INTO {0} {1};",
mappings.TableName,
insertBuilder.ToSqlString(TSqlBuilder.Instance));
sqlbuilder.Append(TSqlBuilder.Instance.DBStatementSeperator);
sqlbuilder.Append(insertSql);
sqlbuilder.Append(TSqlBuilder.Instance.DBStatementSeperator);
sqlbuilder.Append("SELECT @CURRENTTIME");
}
private string GetMoveSysTaskSql(SysAccomplishedTask taskCompleted, Dictionary <string, object> context)
{
ORMappingItemCollection mappings = GetMappingInfo(context);
ORMappingItemCollection mappingsCompleted = ORMapping.GetMappingInfo <SysAccomplishedTask>();
InsertSqlClauseBuilder insertBuilder = ORMapping.GetInsertSqlClauseBuilder(taskCompleted, "EndTime", "Status", "StatusText");
string[] fields = insertBuilder.GetAllDataFields();
string affectedFields = string.Join(",", fields);
string sql = string.Format("INSERT INTO {0}({1}, END_TIME, STATUS, STATUS_TEXT) SELECT {2}, GETDATE() AS END_TIME, {3} AS STATUS, {4} AS STATUS_TEXT FROM {5} WHERE TASK_GUID = {6}",
mappingsCompleted.TableName,
affectedFields,
affectedFields,
TSqlBuilder.Instance.CheckUnicodeQuotationMark(taskCompleted.Status.ToString()),
TSqlBuilder.Instance.CheckUnicodeQuotationMark(taskCompleted.StatusText),
mappings.TableName,
TSqlBuilder.Instance.CheckUnicodeQuotationMark(taskCompleted.TaskID));
return(sql);
}
/// <summary>
/// 更新相关的数据。先删除某个ResouceID和ClassName下相关的数据，然后再插入集合中的数据
/// </summary>
/// <typeparam name="TRelative"></typeparam>
/// <param name="resourceID"></param>
/// <param name="className"></param>
/// <param name="dataCollection"></param>
public virtual void UpdateRelativeData <TRelative>(string resourceID, string className, IEnumerable <TRelative> dataCollection) where TRelative : GenericFormRelativeData
{
resourceID.CheckStringIsNullOrEmpty("resourceID");
className.CheckStringIsNullOrEmpty("className");
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
builder.AppendItem("RESOURCE_ID", resourceID).AppendItem("CLASS", className);
builder.AppendTenantCode(typeof(TRelative));
StringBuilder strB = new StringBuilder();
strB.AppendFormat("DELETE WF.GENERIC_FORM_RELATIVE_DATA WHERE {0}", builder.ToSqlString(TSqlBuilder.Instance));
int i = 0;
foreach (TRelative data in dataCollection)
{
data.ResourceID = resourceID;
data.Class = className;
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
InsertSqlClauseBuilder insertBuilder = ORMapping.GetInsertSqlClauseBuilder(data, "ResourceID", "Class", "SortID", "XmlContent");
data.SortID = i++;
insertBuilder.AppendItem("RESOURCE_ID", resourceID).AppendItem("CLASS", className).AppendItem("SORT_ID", data.SortID);
XmlDocument xdoc = XmlHelper.SerializeObjectToXml(data);
data.XmlContent = xdoc.OuterXml;
insertBuilder.AppendItem("XML_CONTENT", xdoc.OuterXml);
strB.AppendFormat("INSERT WF.GENERIC_FORM_RELATIVE_DATA{0}", insertBuilder.ToSqlString(TSqlBuilder.Instance));
}
DbHelper.RunSqlWithTransaction(strB.ToString(), GetConnectionName());
}
private string GetUpdateSql(string containerID, SCAclContainerOrMemberCollectionBase members)
{
return(VersionStrategyUpdateSqlHelper.ConstructUpdateSql(
null, (strB, context) =>
{
string tableName = this.GetMappingInfo().TableName;
ConnectiveSqlClauseCollection connectiveBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder();
WhereSqlClauseBuilder keyBuilder = new WhereSqlClauseBuilder();
keyBuilder.AppendItem("ContainerID", containerID);
connectiveBuilder.Add(keyBuilder);
strB.AppendFormat(
"UPDATE {0} SET VersionEndTime = {1} WHERE {2}",
tableName,
"@currentTime",
connectiveBuilder.ToSqlString(TSqlBuilder.Instance));
for (int i = 0; i < members.Count; i++)
{
SCAclItem aclitem = members[i];
aclitem.SortID = i;
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
aclitem.VersionEndTime = ConnectionDefine.MaxVersionEndTime;
InsertSqlClauseBuilder insertBuilder = ORMapping.GetInsertSqlClauseBuilder(aclitem, this.GetMappingInfo(), "VersionStartTime");
insertBuilder.AppendItem("VersionStartTime", "@currentTime", "=", true);
strB.AppendFormat("INSERT INTO {0}{1}", tableName, insertBuilder.ToSqlString(TSqlBuilder.Instance));
}
}));
}
public StringBuilder InnerUpdateSql(T data, DateTime versionTime, WhereSqlClauseBuilder SqlWhere)
{
StringBuilder sqlbuilder = new StringBuilder();
ORMappingItemCollection mappings = GetMappingInfo(new Dictionary <string, object>());
if (versionTime == DateTime.MinValue)
{
versionTime = SNTPClient.AdjustedTime;
}
sqlbuilder.Append("DECLARE @CURRENTTIME DATETIME");
sqlbuilder.Append(TSqlBuilder.Instance.DBStatementSeperator);
sqlbuilder.AppendFormat(
@" SET @CURRENTTIME = {0} {3} UPDATE {1} SET VersionEndTime = @CURRENTTIME WHERE {2}; ",
TSqlBuilder.Instance.FormatDateTime(versionTime),
mappings.TableName,
SqlWhere.ToSqlString(TSqlBuilder.Instance),
TSqlBuilder.Instance.DBStatementSeperator
);
InsertSqlClauseBuilder insertBuilder = ORMapping.GetInsertSqlClauseBuilder(data, mappings, "VersionStartTime");
insertBuilder.AppendItem("VersionStartTime", "@CURRENTTIME", "=", true);
string insertSql =
string.Format("INSERT INTO {0} {1};",
mappings.TableName,
insertBuilder.ToSqlString(TSqlBuilder.Instance));
sqlbuilder.Append(TSqlBuilder.Instance.DBStatementSeperator);
sqlbuilder.Append(insertSql);
sqlbuilder.Append(TSqlBuilder.Instance.DBStatementSeperator);
sqlbuilder.Append("SELECT @CURRENTTIME");
return(sqlbuilder);
}
public void SaveProcess(IWfProcess process)
{
WfProcessInstanceData instanceData = WfProcessInstanceData.FromProcess(process);
if (instanceData.Data.IsNotEmpty())
{
if (WorkflowSettings.GetConfig().Compressed)
{
XElement extData = GetExtData(instanceData.ExtData);
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration("CompressProcess", () =>
{
instanceData.BinaryData = GetCompressedStream(instanceData.Data, Encoding.GetEncoding(extData.Attribute("encoding", "utf-8")));
instanceData.Data = string.Empty;
});
}
}
string sql = string.Empty;
ORMappingItemCollection mapping = ORMapping.GetMappingInfo <WfProcessInstanceData>();
if (process.LoadingType == DataLoadingType.External)
{
UpdateSqlClauseBuilder uBuilder = ORMapping.GetUpdateSqlClauseBuilder(instanceData, mapping);
uBuilder.AppendItem("UPDATE_TAG", "UPDATE_TAG + 1", "=", true);
uBuilder.AppendTenantCode();
WhereSqlClauseBuilder whereBuilder = ORMapping.GetWhereSqlClauseBuilderByPrimaryKey(instanceData, mapping);
whereBuilder.AppendItem("UPDATE_TAG", process.UpdateTag);
sql = string.Format("UPDATE {0} SET {1} WHERE {2}",
mapping.TableName, uBuilder.ToSqlString(TSqlBuilder.Instance), whereBuilder.ToSqlString(TSqlBuilder.Instance));
}
else
{
InsertSqlClauseBuilder iBuilder = ORMapping.GetInsertSqlClauseBuilder(instanceData, mapping);
iBuilder.AppendTenantCode();
sql = string.Format("INSERT INTO {0} {1}", mapping.TableName, iBuilder.ToSqlString(TSqlBuilder.Instance));
}
Dictionary <object, object> context = new Dictionary <object, object>();
using (TransactionScope scope = TransactionScopeFactory.Create())
{
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration("WriteProcessToDB", () =>
(DbHelper.RunSql(sql, GetConnectionName()) > 0).FalseThrow <WfRuntimeException>(
Translator.Translate(Define.DefaultCulture, "更新流程{0}失败，流程状态已经改变", process.ID))
);
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration("WriteProcessActivitiesToDB",
() => WfProcessCurrentActivityAdapter.Instance.UpdateProcessActivities(process));
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration("WriteRelativeProcessInfoToDB", () =>
{
WfRelativeProcessAdapter.Instance.Delete(new WfRelativeProcess()
{
ProcessID = process.ID
});
if (process.RelativeID.IsNotEmpty())
{
WfRelativeProcessAdapter.Instance.Update(new WfRelativeProcess()
{
Description = string.IsNullOrEmpty(process.Descriptor.Description) ? process.Descriptor.Name : process.Descriptor.Description,
ProcessID = process.ID,
RelativeID = process.RelativeID,
RelativeURL = process.RelativeURL
});
}
});
if (WorkflowSettings.GetConfig().SaveRelativeData)
{
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration("WriteRelativeDataToDB",
() => WfExtraPersistenceSettings.GetConfig().GetPersisters().SaveData(process, context));
}
scope.Complete();
}
}
