public string GetExecutionData(EmailTemplateUserTask userTask)
{
string informationOnStep = LocalizableString.IsNullOrEmpty(userTask.InformationOnStep)
? userTask.GetParameterValue("InformationOnStep")?.ToString() ?? string.Empty
: userTask.InformationOnStep.Value;
string allowedActivityResults = ProcessUserTaskUtilities.GetAllowedActivityResults(UserConnection,
userTask.ActivityId);
Guid parentProcessId = ProcessUserTaskUtilities.GetParentProcessId(userTask.Owner);
return
(ServiceStackTextHelper.Serialize(
new {
procElUId = userTask.UId,
name = userTask.Name,
processId = parentProcessId,
isProcessExecutedBySignal = userTask.Owner.IsProcessExecutedBySignal,
processName = userTask.Owner.Name,
entitySchemaName = "Activity",
recommendation = GetActivityTitle(userTask),
informationOnStep,
pageTypeId = ActivityConsts.EmailTypeUId,
activityRecordId = userTask.ActivityId,
executionContext = userTask.ExecutionContext,
nextProcElUId = "nextProcElUIdValue",
allowedResults = allowedActivityResults
}));
}
/// <inheritdoc />
public override ProcessElementNotification GetNotificationData()
{
ProcessElementNotification notification = base.GetNotificationData();
ProcessUserTaskUtilities.AssignNotificationData(notification, Recommendation, StartIn, StartInPeriod);
return(notification);
}
public virtual void UpdateEntityCollection(EntityCollection entityCollection, EntitySchema entitySchema)
{
string GetDebugInfo(Entity source)
{
var info = new System.Text.StringBuilder();
try {
info.Append(source.SchemaName);
info.Append($" ({source.Schema.PrimaryColumn.Name}: [{source.PrimaryColumnValue}])");
} catch (Exception) {
}
return(info.ToString());
}
foreach (Entity entity in entityCollection)
{
try {
foreach (KeyValuePair <string, object> columnValue in RecordColumnValues.Values)
{
EntitySchemaColumn column = entitySchema.GetSchemaColumnByMetaPath(columnValue.Key);
object value = columnValue.Value;
if (ProcessUserTaskUtilities.GetIsEmptyLookupOrDateTimeValue(value, column.DataValueType))
{
value = null;
}
entity.SetColumnValue(column, value);
}
entity.UseAdminRights = false;
entity.Save(false);
} catch (Exception e) {
string debugInfo = GetDebugInfo(entity);
Log.Error("An error occurred during process element {this} when updating an entity {debugInfo}", e);
}
}
}
/// <summary>
/// Determines whether the conditions is satisfied.
/// </summary>
/// <returns><c>true</c> when conditions are successfully checked; otherwise - <c>false</c>.</returns>
public virtual bool GetIsMatchedConditions()
{
if (!IsMatchConditions || DataSourceFilters.IsNullOrEmpty())
{
return(true);
}
CoreEntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByUId(ObjectSchemaId);
var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, entitySchema.Name)
{
UseAdminRights = false
};
esq.AddColumn(entitySchema.PrimaryColumn.Name);
ProcessUserTaskUtilities.SpecifyESQFilters(UserConnection, this, entitySchema, esq, DataSourceFilters);
if (esq.Filters.Count == 0)
{
return(true);
}
if (esq.Filters.Count == 1)
{
if (esq.Filters[0] is EntitySchemaQueryFilterCollection filterGroup && filterGroup.Count == 0)
{
return(true);
}
}
Entity entity = esq.GetEntity(UserConnection, RecordId);
return(entity != null);
}
public bool CompleteExecuting(EmailTemplateUserTask userTask, Func <object[], bool> callBase,
params object[] parameters)
{
var activity = parameters[0] as Activity;
if (activity == null)
{
return(false);
}
userTask.OwnerId = activity.OwnerId;
IEnumerable <string> activityConnections = GetActivityConnections();
foreach (string activityConnection in activityConnections)
{
SetParameterByActivity(userTask, activity, activityConnection);
}
ProcessUserTaskUtilities.SetEntityColumnValues(userTask, activity);
userTask.ActivityResult = activity.ResultId;
userTask.IsActivityCompleted = true;
bool result = callBase(parameters);
activity.SetColumnValue("ProcessElementId", null);
activity.UseAdminRights = false;
activity.Save();
return(result);
}
protected override bool InternalExecute(ProcessExecutingContext context)
{
if (EntityCollection == null || EntityCollection.Count == 0)
{
return(true);
}
EntitySchema entitySchema = EntityCollection.Schema;
if (string.IsNullOrEmpty(DataSourceFilters) || entitySchema == null)
{
return(true);
}
DataSourceFilterCollection dataSourceFilters =
ProcessUserTaskUtilities.ConvertToProcessDataSourceFilterCollection(
UserConnection, entitySchema, this, DataSourceFilters);
if (dataSourceFilters == null || dataSourceFilters.Count == 0)
{
return(true);
}
var dataSourceFiltersIsNot = new DataSourceFilterCollection(dataSourceFilters)
{
LogicalOperation = LogicalOperationStrict.And,
IsEnabled = true
};
var linqConverter = new DataSourceFilterLinqConverter(UserConnection);
IQueryable <Entity> resultQuery = linqConverter.BuildQuery(EntityCollection, dataSourceFiltersIsNot);
EntityCollection.RemoveRange(resultQuery.ToArray());
return(true);
}
public override string GetExecutionData()
{
LocalizableParameterValuesList decisionOptionItems = null;
if (BranchingDecisions.Value.IsNotNullOrEmpty())
{
Process process = Owner;
ProcessSchema processSchema = process.ProcessSchema;
string resourceManagerName = processSchema.OwnerSchema == null
? processSchema.GetResourceManagerName()
: processSchema.OwnerSchema.GetResourceManagerName();
var element = processSchema.GetBaseElementByUId(SchemaElementUId);
var resourceItemName = "BaseElements." + element.Name + ".Parameters.BranchingDecisions.Value";
var localizableString = new LocalizableString(Storage, resourceManagerName, resourceItemName);
string value = localizableString.Value;
if (value.IsNotNullOrEmpty())
{
decisionOptionItems = LocalizableParameterValuesList.DeserializeFrom77FormatData(value, "Caption");
}
else
{
decisionOptionItems = LocalizableParameterValuesList.DeserializeData(BranchingDecisions.Value);
decisionOptionItems.SetupDefaultLocalizableValues("Caption", NoCaptionLocalizableString.Value);
}
}
string informationOnStep = LocalizableString.IsNullOrEmpty(InformationOnStep)
? GetParameterValue("InformationOnStep")?.ToString() ?? string.Empty
: InformationOnStep.Value;
string executionData = SerializeToString(new {
procElUId = UId,
name = Name,
processId = ProcessUserTaskUtilities.GetParentProcessId(Owner),
isProcessExecutedBySignal = ProcessUserTaskUtilities.GetIsProcessExecutedBySignal(Owner),
processName = Owner.Name,
urlToken = "ProcessCardModuleV2/UserQuestionProcessPageV2",
recommendation = GetActivityTitle(),
informationOnStep,
activityRecordId = CurrentActivityId,
questionText = Question.ToString(),
decisionMode = DecisionMode,
isDecisionRequired = IsDecisionRequired,
decisionOptions = decisionOptionItems?.To77FormatList(),
executionContext = ExecutionContext,
nextProcElUId = "nextProcElUIdValue"
});
string userContextData = ProcessLane?.GetUserContextData();
if (!string.IsNullOrEmpty(userContextData))
{
var sb = new StringBuilder(executionData);
sb.Length--;
sb.Append(",");
sb.Append(userContextData);
sb.Append("}");
executionData = sb.ToString();
}
return(executionData);
}
/// <inheritdoc />
protected override bool InternalExecute(ProcessExecutingContext context)
{
bool isRedo = (Status == ProcessStatus.Error && CurrentActivityId == Guid.Empty &&
!ProcessUserTaskUtilities.GetIsActivityCreated(UserConnection, UId));
bool isRunning = !CurrentActivityId.Equals(Guid.Empty) && !IsActivityCompleted;
if (!isRunning || isRedo)
{
var editMode = (RecordEditMode)Enum.ToObject(typeof(RecordEditMode), EditMode);
bool isActivityEntitySchema = GetIsActivityEntitySchema();
Entity activity = null;
IProcessEngine processEngine = UserConnection.ProcessEngine;
if (isActivityEntitySchema)
{
if (editMode == RecordEditMode.New)
{
activity = CreateActivity();
RecordId = CurrentActivityId;
}
else
{
CurrentActivityId = RecordId;
}
}
else
{
Entity accompaningActivity = CreateAccompaningActivity();
CoreEntitySchema activityEntitySchema = GetActivityEntitySchema();
Guid resultColumnUId = activityEntitySchema.Columns.GetByName("Status").UId;
processEngine.AddProcessListener(accompaningActivity, UId,
GetConditionData(resultColumnUId, accompaningActivity));
if (editMode == RecordEditMode.New)
{
RecordId = Guid.NewGuid();
}
}
string serializedFilters = IsMatchConditions && DataSourceFilters.IsNotNullOrEmpty()
? ConvertToProcessDataSourceFilters(ObjectSchemaId, DataSourceFilters)
: null;
if (activity == null)
{
if (editMode != RecordEditMode.New)
{
processEngine.AddProcessListener(RecordId, ObjectSchemaId, UId, serializedFilters);
}
else
{
processEngine.AddProcessListener(RecordId, ObjectSchemaId, UId, null, null,
EntityChangeType.Inserted);
}
}
else
{
processEngine.AddProcessListener(activity, UId, serializedFilters);
}
}
InteractWithUser(context, isRunning, ShowExecutionPage);
return(false);
}
public override bool CompleteExecuting(params object[] parameters)
{
ProcessUserTaskUtilities.DeactivateProcessEntryPoint(UserConnection, EntryPointId, EntitySchemaUId, EntityId);
ThrowSignal();
bool result = base.CompleteExecuting(parameters);
return(result);
}
protected virtual void LinkActivityToProcess(Activity activity, EmailTemplateUserTask userTask)
{
Guid resultColumntUId = activity.Schema.Columns.GetByName("Status").UId;
string conditionData =
ProcessUserTaskUtilities.GetConditionData(UserConnection, resultColumntUId, activity);
UserConnection.IProcessEngine.AddProcessListener(activity, userTask.UId, conditionData);
UserConnection.IProcessEngine.LinkProcessToEntity(userTask.Owner, activity.Schema.UId, activity.Id);
}
protected override bool InternalExecute(ProcessExecutingContext context)
{
if (EntryPointId.IsEmpty())
{
EntryPointId = ProcessUserTaskUtilities.AddProcessEntryPoint(UserConnection, EntitySchemaUId, EntityId,
UId);
}
InteractWithUser(context, IsRunning, ShowExecutionPage);
IsRunning = true;
return(false);
}
private void FillActivityConnections(Activity activity, EmailTemplateUserTask userTask)
{
IEnumerable <string> activityConnections = GetActivityConnections();
foreach (string activityConnection in activityConnections)
{
object propertyValue = userTask.GetPropertyValue(activityConnection);
ProcessUserTaskUtilities.SetEntityColumnValue(activity, activityConnection, propertyValue);
}
ProcessUserTaskUtilities.SetEntityColumnValues(userTask, activity);
}
public virtual void FillRowWithData(Entity entity)
{
foreach (var columnValue in RecordDefValues.Values)
{
var column = entity.Schema.GetSchemaColumnByMetaPath(columnValue.Key);
object value = columnValue.Value;
if (ProcessUserTaskUtilities.GetIsEmptyLookupOrDateTimeValue(value, column.DataValueType))
{
continue;
}
entity.SetColumnValue(column, value);
}
}
public virtual IQueryable <Entity> CreateQuery()
{
DataSourceFilterCollection filterCollection = null;
if (!string.IsNullOrEmpty(DataSourceFilters))
{
filterCollection = ProcessUserTaskUtilities.ConvertToProcessDataSourceFilterCollection(
UserConnection, SamplingEntityCollection.Schema, this, DataSourceFilters);
}
var linqConvertor = new DataSourceFilterLinqConverter(UserConnection);
return(linqConvertor.BuildQuery(SamplingEntityCollection, filterCollection));
}
private static void SetActivityRemindToOwnerDate(Activity activity, EmailTemplateUserTask userTask)
{
if (userTask.OwnerId.IsNotEmpty())
{
activity.OwnerId = userTask.OwnerId;
if (userTask.RemindBefore != 0)
{
activity.RemindToOwner = true;
var processDurationPeriod = (ProcessDurationPeriod)userTask.RemindBeforePeriod;
DateTime remindToOwnerDate = ProcessUserTaskUtilities.NewDate(activity.StartDate, -1 * userTask.RemindBefore,
processDurationPeriod);
activity.RemindToOwnerDate = remindToOwnerDate;
}
}
}
public override bool CompleteExecuting(params object[] parameters)
{
Guid activityStatusId = ProcessUserTaskUtilities.GetActivityStatus(UserConnection, CurrentActivityId);
if (activityStatusId != ActivityConsts.CanceledStatusUId)
{
activityStatusId = ActivityConsts.CompletedStatusUId;
}
if (UserConnection.IProcessEngine.RemoveActivityProcessListener(CurrentActivityId, UId, activityStatusId))
{
IsActivityCompleted = true;
return(base.CompleteExecuting(parameters));
}
return(false);
}
/// <inheritdoc />
public override string GetExecutionData()
{
CoreEntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByUId(ObjectSchemaId);
var defaultColumnValues = new Dictionary <string, object>();
foreach (var columnValue in RecordColumnValues.Values)
{
var column = entitySchema.GetSchemaColumnByMetaPath(columnValue.Key);
if ((column.DataValueType is LookupDataValueType || column.DataValueType is MultiLookupDataValueType) &&
((Guid)columnValue.Value).IsEmpty())
{
continue;
}
defaultColumnValues[column.Name] = SerializeEntityColumn(column, columnValue.Value);
}
var editMode = (RecordEditMode)Enum.ToObject(typeof(RecordEditMode), EditMode);
if (editMode == RecordEditMode.New)
{
EntitySchemaColumnCollection columns = entitySchema.Columns;
defaultColumnValues["ProcessListeners"] =
SerializeEntityColumn(columns.GetByName("ProcessListeners"), (int)EntityChangeType.Inserted);
}
string actionName = GetActionName();
string informationOnStep = LocalizableString.IsNullOrEmpty(InformationOnStep)
? GetParameterValue("InformationOnStep")?.ToString() ?? string.Empty
: InformationOnStep.Value;
return(SerializeToString(new {
processId = ProcessUserTaskUtilities.GetParentProcessId(Owner),
procElUId = UId,
name = Name,
isProcessExecutedBySignal = ProcessUserTaskUtilities.GetIsProcessExecutedBySignal(Owner),
processName = Owner.Name,
action = actionName,
entitySchemaName = entitySchema.Name,
recordId = RecordId,
activityRecordId = CurrentActivityId,
recommendation = GetActivityTitle(),
informationOnStep,
defaultValues = defaultColumnValues.Count > 0 ? defaultColumnValues : null,
executionContext = ExecutionContext,
completeExecution = actionName == "add",
pageTypeId = PageTypeUId == Guid.Empty ? string.Empty : PageTypeUId.ToString(),
nextProcElUId = "nextProcElUIdValue"
}));
}
public override string GetExecutionData()
{
var sb = new StringBuilder(512);
string parameterConfigs = GenerateParameterConfigs(sb);
string valueConfigs = sb.ToString();
sb.Length = 0;
string pageSchemaConfig = GeneratePageSchemaConfigs(sb, valueConfigs);
sb.Length = 0;
bool isNotFirstProperty = false;
string uid = UId.ToString();
object title = GetParameterValue("Title") ?? string.Empty;
object recommendation = GetParameterValue("Recommendation") ?? string.Empty;
object informationOnStep = GetParameterValue("InformationOnStep") ?? string.Empty;
sb.Append("{");
AppendJSonProperty(sb, "procElUId", uid, 1, ref isNotFirstProperty);
AppendJSonProperty(sb, "name", Name, 1, ref isNotFirstProperty);
AppendJSonProperty(sb, "processId", ProcessUserTaskUtilities.GetParentProcessId(Owner), 1,
ref isNotFirstProperty);
AppendJSonProperty(sb, "isProcessExecutedBySignal",
ProcessUserTaskUtilities.GetIsProcessExecutedBySignal(Owner), 2, ref isNotFirstProperty);
AppendJSonProperty(sb, "processName", Owner.Name, 1, ref isNotFirstProperty);
AppendJSonProperty(sb, "title", title, 1, ref isNotFirstProperty);
AppendJSonProperty(sb, "recommendation", recommendation, 1, ref isNotFirstProperty);
AppendJSonProperty(sb, "informationOnStep", informationOnStep, 1, ref isNotFirstProperty);
AppendJSonProperty(sb, "nextProcElUId", "nextProcElUIdValue", 1, ref isNotFirstProperty);
AppendJSonProperty(sb, "urlToken", "ProcessCardModuleV2/AutoGeneratedPageV2", 1, ref isNotFirstProperty);
AppendJSonProperty(sb, "autoGeneratedPage", true, 1, ref isNotFirstProperty);
if (EntityId != Guid.Empty)
{
AppendJSonProperty(sb, "recordId", EntityId, 1, ref isNotFirstProperty);
}
AppendJSonProperty(sb, "pageSchema", pageSchemaConfig, 3, ref isNotFirstProperty);
AppendJSonProperty(sb, "parameters", parameterConfigs, 3, ref isNotFirstProperty);
string userContextData = ProcessLane?.GetUserContextData();
if (!string.IsNullOrEmpty(userContextData))
{
sb.Append(",");
sb.Append(userContextData);
}
sb.Append("}");
return(sb.ToString());
}
public virtual void FillRowWithDataByFilter(Entity entity, Entity filterEntity, Dictionary <string, string> entityColumnMap)
{
FillRowWithData(entity);
foreach (var columnValue in RecordDefValues.FetchMetaPathes)
{
var column = entity.Schema.GetSchemaColumnByMetaPath(columnValue.Key);
EntitySchemaColumn filterColumn = filterEntity.Schema.GetSchemaColumnByPath(entityColumnMap[columnValue.Value]);
var filterValue = filterEntity.GetColumnValue(filterColumn);
if (filterValue != null)
{
if (ProcessUserTaskUtilities.GetIsEmptyLookupOrDateTimeValue(filterValue, column.DataValueType))
{
continue;
}
entity.SetColumnValue(column, filterValue);
}
}
}
/// <inheritdoc />
public override bool CompleteExecuting(params object[] parameters)
{
bool isActivityEntitySchema = GetIsActivityEntitySchema();
Guid activityStatusId = isActivityEntitySchema
? Guid.Empty
: ProcessUserTaskUtilities.GetActivityStatus(UserConnection, CurrentActivityId);
IProcessEngine processEngine = UserConnection.ProcessEngine;
if (GetIsMatchedConditions())
{
if (!isActivityEntitySchema && activityStatusId != ActivityConsts.CanceledStatusUId)
{
activityStatusId = ActivityConsts.CompletedStatusUId;
}
processEngine.RemoveActivityProcessListener(CurrentActivityId, UId, activityStatusId);
if (!GetIsActivityEntitySchema())
{
var editMode = (RecordEditMode)Enum.ToObject(typeof(RecordEditMode), EditMode);
EntityChangeType entityChangeType = editMode == RecordEditMode.New
? EntityChangeType.Inserted
: EntityChangeType.Updated;
processEngine.RemoveProcessListener(RecordId, ObjectSchemaId, UId, entityChangeType);
}
if (GenerateDecisionsFromColumn)
{
ResultParameter = GetResultParameter();
}
return(base.CompleteExecuting(parameters));
}
if ((RecordEditMode)Enum.ToObject(typeof(RecordEditMode), EditMode) == RecordEditMode.New)
{
string serializedFilters = IsMatchConditions && DataSourceFilters.IsNotNullOrEmpty()
? ConvertToProcessDataSourceFilters(ObjectSchemaId, DataSourceFilters)
: null;
processEngine.AddProcessListener(RecordId, ObjectSchemaId, UId, serializedFilters);
EditMode = (int)RecordEditMode.Existing;
}
if (activityStatusId == ActivityConsts.NewStatusUId)
{
ProcessUserTaskUtilities.SetActivityStatus(UserConnection, CurrentActivityId,
ActivityConsts.InProgressUId);
}
return(false);
}
protected override bool InternalExecute(ProcessExecutingContext context)
{
if (EntitySchemaUId.Equals(Guid.Empty))
{
return(false);
}
EntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByUId(EntitySchemaUId);
if (RecordColumnValues.Values.Count == 0)
{
return(true);
}
var entitySchemaQuery = new EntitySchemaQuery(UserConnection.EntitySchemaManager, entitySchema.Name);
entitySchemaQuery.UseAdminRights = false;
entitySchemaQuery.IgnoreDisplayValues = GlobalAppSettings.FeatureIgnoreDisplayValuesInDataUserTasks;
entitySchemaQuery.AddAllSchemaColumns();
if (IsMatchConditions)
{
ProcessUserTaskUtilities.SpecifyESQFilters(UserConnection, this, entitySchema, entitySchemaQuery,
DataSourceFilters);
bool isEmptyFilter = entitySchemaQuery.Filters.Count == 0;
if (!isEmptyFilter && entitySchemaQuery.Filters.Count == 1)
{
var filterGroup = entitySchemaQuery.Filters[0] as EntitySchemaQueryFilterCollection;
if (filterGroup != null && filterGroup.Count == 0)
{
isEmptyFilter = true;
}
}
if (isEmptyFilter)
{
throw new NullOrEmptyException(new LocalizableString("Terrasoft.Core",
"ProcessSchemaChangeDataUserTask.Exception.ChangeDataWithEmptyFilter"));
}
}
EntityCollection entityCollection = entitySchemaQuery.GetEntityCollection(UserConnection);
UpdateEntityCollection(entityCollection, entitySchema);
return(true);
}
protected override bool InternalExecute(ProcessExecutingContext context)
{
if (Status == ProcessStatus.Error)
{
if (CurrentActivityId == Guid.Empty &&
!ProcessUserTaskUtilities.GetIsActivityCreated(UserConnection, UId))
{
Activity activity = CreateActivity();
AfterActivitySaveScriptExecute(activity);
}
}
bool isRunning = CurrentActivityId.IsNotEmpty() && !IsActivityCompleted;
if (!isRunning)
{
Activity activity = CreateActivity();
AfterActivitySaveScriptExecute(activity);
}
InteractWithUser(context, isRunning, ShowExecutionPage);
return(false);
}
public override string GetExecutionData()
{
var element = (IProcessElementMetaInfo)GetSchemaElement();
var informationOnStepParameter = element.Parameters.GetByName("InformationOnStep");
var informationOnStep = GetParameterValue(informationOnStepParameter) ?? string.Empty;
return(SerializeToString(new {
procElUId = UId,
name = Name,
processId = ProcessUserTaskUtilities.GetParentProcessId(Owner),
isProcessExecutedBySignal = ProcessUserTaskUtilities.GetIsProcessExecutedBySignal(Owner),
processName = Owner.Name,
entitySchemaName = "Activity",
recommendation = GetActivityTitle(),
informationOnStep = informationOnStep.ToString(),
pageTypeId = ActivityConsts.TaskTypeUId,
activityRecordId = CurrentActivityId,
executionContext = ExecutionContext,
nextProcElUId = "nextProcElUIdValue",
allowedResults = ProcessUserTaskUtilities.GetAllowedActivityResults(UserConnection, CurrentActivityId)
}));
}
public virtual void UpdateEntityCollection(EntityCollection entityCollection, EntitySchema entitySchema)
{
foreach (var entity in entityCollection)
{
try {
foreach (KeyValuePair <string, object> columnValue in RecordColumnValues.Values)
{
EntitySchemaColumn column = entitySchema.GetSchemaColumnByMetaPath(columnValue.Key);
object value = columnValue.Value;
if (ProcessUserTaskUtilities.GetIsEmptyLookupOrDateTimeValue(value, column.DataValueType))
{
value = null;
}
entity.SetColumnValue(column, value);
}
entity.UseAdminRights = false;
entity.Save(false);
} catch (Exception e) {
Log.Error(e);
}
}
}
protected override bool InternalExecute(ProcessExecutingContext context)
{
EntitySchemaId.CheckArgumentEmpty("EntitySchemaId");
EntitySchemaManager entitySchemaManager = UserConnection.EntitySchemaManager;
EntitySchema entitySchema = entitySchemaManager.GetInstanceByUId(EntitySchemaId);
var esq = new EntitySchemaQuery(entitySchemaManager, entitySchema.Name)
{
UseAdminRights = false
};
esq.AddAllSchemaColumns();
esq.IgnoreDisplayValues = GlobalAppSettings.FeatureIgnoreDisplayValuesInDataUserTasks;
ProcessUserTaskUtilities.SpecifyESQFilters(UserConnection, this, entitySchema, esq, DataSourceFilters);
bool isEmptyFilter = esq.Filters.Count == 0;
if (!isEmptyFilter && esq.Filters.Count == 1)
{
var filterGroup = esq.Filters[0] as EntitySchemaQueryFilterCollection;
if (filterGroup != null && filterGroup.Count == 0)
{
isEmptyFilter = true;
}
}
if (isEmptyFilter)
{
throw new NullOrEmptyException(new LocalizableString("Terrasoft.Core",
"ProcessSchemaDeleteDataUserTask.Exception.DeleteDataWithEmptyFilter"));
}
EntityCollection entities = esq.GetEntityCollection(UserConnection);
while (entities.Count > 0)
{
Entity entity = entities.First.Value;
entity.UseAdminRights = false;
entities.RemoveFirst();
entity.Delete();
}
return(true);
}
public bool Execute(IEmailUserTaskMessageProvider messageProvider, ProcessExecutingContext context)
{
var userTask = messageProvider.EmailUserTask;
Guid activityId = userTask.ActivityId;
bool showExecutionPage = userTask.ShowExecutionPage;
bool isActivityCompleted = userTask.IsActivityCompleted;
bool isRunning = activityId.IsNotEmpty() && !isActivityCompleted;
if (userTask.Status == ProcessStatus.Error)
{
bool isActivityCreated = ProcessUserTaskUtilities.GetIsActivityCreated(UserConnection, userTask.UId);
if (activityId.IsEmpty() && !isActivityCreated)
{
InternalExecute(messageProvider);
}
}
if (!isRunning)
{
InternalExecute(messageProvider);
}
userTask.InteractWithUser(context, isRunning, showExecutionPage);
return(false);
}
public virtual EntityCollection GetFilterResultEntityCollection(out Dictionary <string, string> entityColumnMap)
{
entityColumnMap = null;
if (FilterEntitySchemaId.Equals(Guid.Empty))
{
return(null);
}
var entitySchema = GetEntitySchema(FilterEntitySchemaId);
if (entitySchema == null)
{
return(null);
}
var entitySchemaQuery = new EntitySchemaQuery(entitySchema);
entitySchemaQuery.UseAdminRights = false;
if (RecordDefValues.FetchMetaPathes == null || RecordDefValues.FetchMetaPathes.Count == 0)
{
entitySchemaQuery.PrimaryQueryColumn.IsAlwaysSelect = true;
}
else
{
entityColumnMap = new Dictionary <string, string>();
foreach (var columnValue in RecordDefValues.FetchMetaPathes)
{
string columnPath = entitySchema.GetSchemaColumnPathByMetaPath(columnValue.Value);
var queryColumn = entitySchemaQuery.AddColumn(columnPath);
entityColumnMap[columnValue.Value] = queryColumn.Name;
}
}
if (!FilterEntitySchemaId.Equals(Guid.Empty) && DataSourceFilters.IsNotNullOrEmpty())
{
ProcessUserTaskUtilities.SpecifyESQFilters(UserConnection, this, entitySchema, entitySchemaQuery,
DataSourceFilters);
}
return(entitySchemaQuery.GetEntityCollection(UserConnection));
}
private Activity CreateActivity(EmailMessage message, EmailTemplateUserTask userTask)
{
var activity = new Activity(UserConnection);
activity.SetDefColumnValues();
activity.Id = Guid.NewGuid();
activity.TypeId = ActivityConsts.EmailTypeUId;
activity.MessageTypeId = ActivityConsts.OutgoingEmailTypeId;
userTask.Subject = message.Subject;
activity.Title = message.Subject;
activity.StartDate = ProcessUserTaskUtilities.NewDate(
UserConnection.CurrentUser.GetCurrentDateTime(), userTask.StartIn,
(ProcessDurationPeriod)userTask.StartInPeriod);
activity.DueDate = ProcessUserTaskUtilities.NewDate(
activity.StartDate, userTask.Duration, (ProcessDurationPeriod)userTask.DurationPeriod);
if (userTask.ActivityCategory.IsEmpty())
{
userTask.ActivityCategory = ActivityConsts.EmailActivityCategoryId;
}
activity.ActivityCategoryId = userTask.ActivityCategory;
activity.ShowInScheduler = userTask.ShowInScheduler;
activity.Recepient = message.To.ConcatIfNotEmpty(";");
activity.CopyRecepient = message.Cc.ConcatIfNotEmpty(";");
activity.BlindCopyRecepient = message.Bcc.ConcatIfNotEmpty(";");
activity.Body = message.Body;
activity.IsHtmlBody = true;
activity.Sender = message.From;
SetActivityRemindToOwnerDate(activity, userTask);
FillActivityConnections(activity, userTask);
activity.ProcessElementId = userTask.UId;
activity.AllowedResult = userTask.GetResultAllowedValues();
LinkActivityToProcess(activity, userTask);
userTask.IsActivityCompleted = false;
userTask.ActivityId = activity.Id;
return(activity);
}
/// <summary>
/// Returns serialized filter that matches final status column values.
/// </summary>
/// <param name="resultColumnUId">The status column identifier.</param>
/// <param name="activity">The activity.</param>
public virtual string GetConditionData(Guid resultColumnUId, Entity activity)
{
return(ProcessUserTaskUtilities.GetConditionData(UserConnection, resultColumnUId, activity));
}
/// <summary>
/// Returns title of the activity.
/// </summary>
/// <returns>Activity title.</returns>
public virtual string GetActivityTitle()
{
return(ProcessUserTaskUtilities.GetActivityTitle(this, Recommendation, CurrentActivityId));
}
