protected override bool InternalExecute(ProcessExecutingContext context)
{
ProcessSchemaManager processSchemaManager = UserConnection.ProcessSchemaManager;
Guid uid = ProcessSchemaUId;
if (processSchemaManager.FindItemByUId(ProcessSchemaUId) == null)
{
uid = ((Select) new Select(UserConnection).Top(1)
.Column("UId")
.From("SysSchema")
.Where("Id").IsEqual(Column.Parameter(ProcessSchemaUId)))
.ExecuteScalar <Guid>();
}
ProcessSchema processSchema = GetProcessSchema(uid);
if (!processSchema.Enabled)
{
return(true);
}
Dictionary <string, string> nameValueMap = new Dictionary <string, string>();
if (!string.IsNullOrWhiteSpace(CustomPropertyValues))
{
nameValueMap = Common.Json.Json.Deserialize <Dictionary <string, string> >(CustomPropertyValues);
}
nameValueMap["OpportunityId"] = OpportunityId.ToString();
if (CanUseFlowEngine(processSchema))
{
RunFlowEngineProcess(processSchema, nameValueMap);
}
else
{
Process process = processSchema.CreateProcess(UserConnection);
foreach (KeyValuePair <string, string> keyValuePair in nameValueMap)
{
var parameter = processSchema.Parameters.FindByName(keyValuePair.Key);
if (parameter != null)
{
var valueType = parameter.DataValueType.ValueType;
System.ComponentModel.TypeConverter typeConverter =
System.ComponentModel.TypeDescriptor.GetConverter(valueType);
object value = typeConverter.ConvertFromString(keyValuePair.Value);
process.SetPropertyValue(keyValuePair.Key, value);
}
}
process.Execute(UserConnection);
}
return(true);
}
public ActionResult LatestWrite([FromBody] JObject jsonResult)
{
int version = CurrentVersionOfApiToMapTo;
int.TryParse(Request.GetApiVersion(), out version);
jsonResult["version"] = $"v{version}";
var processSchema = new ProcessSchema(JsonConvert.SerializeObject(jsonResult));
_repo.Write(new v1StorageModel.StorageModel()
{
Id = processSchema.Id, VersionOfContents = version, Contents = JsonConvert.SerializeObject(jsonResult)
});
return(Ok());
}
public void Should_construct_object_from_schema()
{
// Arrange
var id = "id";
var title = "title";
var processSchema = new ProcessSchema(id, title);
var str = JsonConvert.SerializeObject(processSchema);
// Act
var schema = new ProcessSchema(str);
// Assert
Assert.True(processSchema.Id == id);
Assert.True(processSchema.Title == title);
}
public void Should_be_able_to_cast_object_back_and_forward()
{
// Arrange
var processSchema = new ProcessSchema();
// Act
var str = processSchema.ToString();
var createdProcessSchema = JsonConvert.DeserializeObject <ProcessSchema>(str);
// Assert
Assert.True(processSchema.Id == createdProcessSchema.Id);
Assert.True(processSchema.Title == createdProcessSchema.Title);
Assert.True(processSchema.Version == createdProcessSchema.Version);
}
public void Should_construct_object_from_atrributes()
{
// Arrange
var id = "id";
var title = "title";
var version = "v1";
// Act
var processSchema = new ProcessSchema(id, title);
// Assert
Assert.True(processSchema.Id == id);
Assert.True(processSchema.Title == title);
Assert.True(processSchema.Version == version);
}
public void Should_make_sure_version_is_different_if_schema_has_different_object()
{
// Arrange
var id = "id";
var title = "title";
var processSchema = new ProcessSchema(id, title);
processSchema.Version = "xxx";
var str = JsonConvert.SerializeObject(processSchema);
// Act
var schema = new ProcessSchema(str);
// Assert
Assert.True(processSchema.Id == id);
Assert.True(processSchema.Title == title);
Assert.True(processSchema.Version == "xxx");
}
/// <summary>
/// Returns page parameters.
/// </summary>
/// <param name="processSchema">Parent process schema.</param>
/// <param name="useLookupValues">Load lookup display value only for new pages.
/// Old pages are using parameter value as simple guid value, not object (value, displayValue)</param>
/// <returns>Parameters dictionary</returns>
private Dictionary <string, object> GetPageParameters(ProcessSchema processSchema, bool useLookupValues)
{
var userTask = (ProcessSchemaUserTask)processSchema.GetBaseElementByUId(SchemaElementUId);
var sysModuleEntityPageType = new Dictionary <Guid, Guid>();
var result = new Dictionary <string, object>();
var dynamicParameters = userTask.Parameters.Where(p => p.CreatedInSchemaUId == processSchema.UId).ToList();
var dateTimeParameters = dynamicParameters.Where(p => p.DataValueType.IsDateTime).ToList();
var lookupParameters = dynamicParameters.Where(p => useLookupValues && p.DataValueType.IsLookup).ToList();
var anotherParameters = dynamicParameters.Except(dateTimeParameters).Except(lookupParameters).ToList();
if (lookupParameters.Count > 0)
{
sysModuleEntityPageType = GetSysModuleEntityPageTypes();
}
dateTimeParameters.ForEach(p => result.Add(p.Name, GetParameterDateTimeValue(p)));
lookupParameters.ForEach(p => result.Add(p.Name, GetParameterLookupValue(p, sysModuleEntityPageType)));
anotherParameters.ForEach(p => result.Add(p.Name, GetParameterValue(p)));
return(result);
}
/// <summary>
/// Returns page parameters.
/// </summary>
/// <param name="processSchema">Parent process schema.</param>
/// <param name="useLookupValues">Load lookup display value only for new pages.
/// Old pages are using parameter value as simple guid value, not object (value, displayValue)</param>
/// <returns>Parameters dictionary</returns>
private Dictionary<string, object> GetPageParameters(ProcessSchema processSchema, bool useLookupValues) {
var userTask = (ProcessSchemaUserTask)processSchema.GetBaseElementByUId(SchemaElementUId);
var result = new Dictionary<string, object>();
foreach (ProcessSchemaParameter parameter in userTask.Parameters) {
if (parameter.CreatedInSchemaUId != processSchema.UId) {
continue;
}
object parameterValue;
if (parameter.DataValueType.IsDateTime) {
parameterValue = GetParameterDateTimeValue(parameter);
} else if (useLookupValues && parameter.DataValueType.IsLookup) {
parameterValue = GetParameterLookupValue(parameter);
} else {
parameterValue = GetParameterValue(parameter) ?? string.Empty;
}
result.Add(parameter.Name, parameterValue);
}
return result;
}
public ProcessCheckResult CheckParameters(Guid processUId, List <ProcessCheckParameter> checkParameters)
{
if ((checkParameters == null) || (checkParameters.Count == 0))
{
return(new ProcessCheckResult {
IsValid = true
});
}
ISchemaManagerItem <ProcessSchema> processManagerItem =
UserConnection.ProcessSchemaManager.FindItemByUId(processUId);
if (processManagerItem == null)
{
string errorText = new LocalizableString(UserConnection.ResourceStorage, "ProcessValidationService",
"LocalizableStrings.ProcessNotFoundErrorText.Value").ToString();
return(new ProcessCheckResult {
IsValid = false,
ErrorText = errorText
});
}
ProcessSchema processSchema = UserConnection.ProcessSchemaManager.GetInstanceByUId(processUId);
var parameters = processSchema.Parameters;
ProcessCheckParameterComparer comparer = new ProcessCheckParameterComparer();
List <ProcessCheckParameter> invalidParameters = checkParameters
.Where(checkParameter => !(parameters
.Select(parameter => new ProcessCheckParameter()
{
Name = parameter.Name,
DataValueTypes = new List <string>(1)
{
parameter.DataValueType.Name
}
})
.Where(parameter => checkParameters.Contains(parameter, comparer))
.ToList <ProcessCheckParameter>()).Contains(checkParameter, comparer)
)
.ToList();
return(new ProcessCheckResult {
IsValid = (invalidParameters.Count == 0),
InvalidParameters = invalidParameters
});
}
private ProcessStatus GetStatusOfProcess(ProcessSchema schema, string userId)
{
if (_userJustCompletedStepCache.UserAndSchemaStored(userId, schema.schemaId))
{
return(ProcessStatus.IN_PROGRESS);
}
var statusus = schema.stepStatuses;
if (statusus[0].completionTime != null)
{
return(ProcessStatus.COMPLETED);
}
if (statusus[statusus.Count - 1].completionTime != null)
{
return(ProcessStatus.IN_PROGRESS);
}
else
{
return(ProcessStatus.ACTION_WITH_USER);
}
}
virtual protected void StartUpdateTargetAudience(Guid id, string rootSchemaName, bool isSetCampaignFirstStep,
string transferTableName)
{
ProcessSchema schema =
UserConnection.ProcessSchemaManager.GetInstanceByName("UpdateTargetAudienceProcess");
Process process = schema.CreateProcess(UserConnection);
process.SetPropertyValue("RootSchemaRecordId", id);
if (!String.IsNullOrWhiteSpace(rootSchemaName))
{
process.SetPropertyValue("RootSchemaName", rootSchemaName);
process.SetPropertyValue("IsSetCampaignFirstStep", isSetCampaignFirstStep);
}
else
{
process.SetPropertyValue("RootSchemaName", "BulkEmailSplit");
process.SetPropertyValue("RootSchemaRecordRId", 1);
process.SetPropertyValue("TargetSchemaBindingColumnValueName", "BulkEmailSplitId");
process.SetPropertyValue("TargetSchemaName", transferTableName);
process.SetPropertyValue("SegmentSchemaName", "BulkEmailSplitSegment");
}
process.Execute(UserConnection);
}
public virtual bool CanUseFlowEngine(ProcessSchema processSchema)
{
return(ProcessSchemaManager.GetCanUseFlowEngine(UserConnection, processSchema));
}
public virtual void RunFlowEngineProcess(ProcessSchema processSchema, Dictionary <string, string> nameValueMap)
{
var flowEngine = new FlowEngine(UserConnection);
flowEngine.RunProcess(processSchema, nameValueMap);
}
private void GetDocument(JObject jsonObject)
{
root = new ProcessSchema().GetPath(jsonObject);
}
protected virtual ProcessSchemaUserTask GetProcessSchemaUserTask(ProcessFlowElement userTask)
{
ProcessSchema processSchema = userTask.Owner.ProcessSchema;
return((ProcessSchemaUserTask)processSchema.GetBaseElementByUId(userTask.SchemaElementUId));
}
