public void Init()
{
_workStepRepository = new MemoryWorkStepRepository();
_workItemRepository = new MemoryWorkItemRepository();
_workflowRepository = new WorkflowRepository(_workItemRepository, _workStepRepository);
_wp = new Workflow(_workflowRepository);
}
public void Init()
{
_workStepRepository = new MemoryWorkStepRepository();
_workItemRepository = new MemoryWorkItemRepository();
var repository = new WorkflowRepository(_workItemRepository, _workStepRepository);
_workflow = new Workflow(repository);
_mover = new WorkItemMover(repository);
_mocks = new MockRepository();
}
public void DeleteWorkflow(string id, string accessKey = null)
{
if (!AccessKeyHelper.CanAccessWorkflows(accessKey))
{
Response.StatusCode = StatusCodes.Status401Unauthorized;
return;
}
var workflowObj = WorkflowRepository.Get(id);
if (workflowObj == null)
{
Response.StatusCode = StatusCodes.Status404NotFound;
return;
}
WorkflowRepository.Delete(workflowObj);
}
/// <summary>
/// Метод для очищения кэша
/// </summary>
public void ClearCache()
{
DocRepository.DocCache.Clear();
// DocDefRepository.DocDefCache.Clear();
DocDefRepository.DocDefDescendantCache.Clear();
/*lock(DocDefRepository.DocDefNameCacheLock)
* DocDefRepository.DocDefNameCache.Clear();*/
// DocDefRepository.ClearDocDefNameCache();
// lock(DocDefRepository.TypeDefCacheLock)
//DocDefRepository.TypeDefCache.Clear();
// DocDefRepository.ClearTypeDefCache();
DocDefRepository.ClearCaches();
UserRepository.UserInfoCache.Clear();
UserRepository.UserOrgCache.Clear();
OrgRepository.OrgInfoCache.Clear();
OrgRepository.OrgTypeInfoCache.Clear();
OrgRepository.OrgPositionInfoCache.Clear();
OrgRepository.OrganizationListCache.Clear();
/*FormRepository.DetailFormCache.Clear();
* FormRepository.TableFormCache.Clear();*/
FormRepository.ClearCaches();
// WorkflowRepository.ActivityCache.Clear();
// WorkflowRepository.ProcessCache.Clear();
// lock (WorkflowRepository.WorkflowProcessStartActivityLock)
// WorkflowRepository.ProcessStartActivities.Clear();
// WorkflowRepository.GateCache.Clear();
// WorkflowRepository.GateRefCache.Clear();
WorkflowRepository.ClearCaches();
PermissionRepository.ObjectDefPermissionCache.Clear();
PermissionRepository.UserPermissionCache.Clear();
PermissionRepository.OrgPositionPermissionCache.Clear();
PermissionRepository.OrgUnitPermissionCache.Clear();
PermissionRepository.RoleListCache.Clear();
EnumRepository.EnumDefCache.Clear();
LanguageRepository.ClearCache();
DocStateRepository.DocStateTypeCache.Clear();
// lock (ScriptManager.ScriptLoadLock)
ScriptManager.ClearCaches();
DocumentTableMapRepository.ClearMaps();
// lock (QueryRepository.QueryDefCacheLock)
QueryRepository.QueryDefCache.Clear();
}
public static void AddWorkflow(RigOapChecklist rigOapChecklist, ILog log, IIrmaOapDbContext context)
{
var workflowActivity = new Genericlist()
{
DisplayName = $"Genericlist_{rigOapChecklist.Id}"
};
var activities = new List <Activity>(WorkflowInspectionServices.GetActivities(workflowActivity));
var indent = 0;
activities.ForEach((act) => Console.WriteLine("{0}{1}", new string(' ', indent), act.DisplayName));
string serializedAB = ToXaml(activities[0]);
var version = new Version(1, 0);
var wfr = new WorkflowRepository(context, log);
var workflow = wfr.GetActiveWorkflow(8);
//var workflow = new Irma.Models.Domain.Workflow.Workflow();
//workflow.Name = "BarrierAuthorityOIM";
//workflow.Major = version.Major;
//workflow.Minor = version.Minor;
//workflow.Active = true;
//workflow.ActivityXaml = ToXaml(workflowActivity);
//var workflowType = workflowActivity.GetType();
//workflow.Assembly = workflowType.Assembly.GetName().Name;
//workflow.Type = workflowType.FullName;
var workflowinstance = new RigOapChecklistWorkflow(rigOapChecklist)
{
Name = $"{workflow.Name} Instance",
Workflow = workflow
};
var wfs = new WorkflowEngineService(log);
var wfir = new RigOapChecklistWorkflowRepository(context, log);
wfs.Start(workflowActivity, version, workflowinstance);
wfir.Add(workflowinstance);
}
public async Task GetDescriptionUsedNotExistsEntitiesInWorkflowAsync(StringBuilder strFile, Guid idWorkflow)
{
try
{
var repository = new WorkflowRepository(_service);
var workflow = await repository.GetByIdAsync(idWorkflow, new ColumnSet(true));
string xmlContent = ContentCoparerHelper.RemoveDiacritics(workflow.Xaml);
var doc = XElement.Parse(xmlContent);
HashSet <Guid> workflowsWithEntities = new HashSet <Guid>()
{
idWorkflow
};
var handler = new WorkflowUsedEntitiesHandler();
Dictionary <EntityReference, HashSet <Guid> > list = (await handler.GetWorkflowUsedEntitiesAsync(doc)).ToDictionary(e => e, k => new HashSet <Guid>()
{
idWorkflow
});
strFile
.AppendFormat("Entity: {0}", workflow.PrimaryEntity).AppendLine()
.AppendFormat("Category: {0}", workflow.FormattedValues[Workflow.Schema.Attributes.category]).AppendLine()
.AppendFormat("Name: {0}", workflow.Name).AppendLine()
.AppendFormat("Url: {0}", _service.UrlGenerator.GetSolutionComponentUrl(ComponentType.Workflow, idWorkflow)).AppendLine()
.AppendLine()
.AppendLine()
.AppendLine()
;
await FillDescriptionNotExistsEntities(strFile, workflowsWithEntities, list);
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(_service.ConnectionData, ex);
}
}
public IHttpActionResult GetCollaborationSigns(string mappingName, Guid workflowInstanceId, string internalActivityId)
{
_logger.WriteDebug(new LogMessage(string.Concat("GetCollaborationSigns -> mappingName = ", mappingName, ", workflowInstanceId = ", workflowInstanceId, ", internalActivityId = ", internalActivityId)), LogCategories);
return(CommonHelpers.ActionHelper.TryCatchWithLoggerGeneric <IHttpActionResult>(() =>
{
ICollection <CollaborationSignModel> signers = new List <CollaborationSignModel>();
if (string.IsNullOrEmpty(mappingName))
{
_logger.WriteError(new LogMessage("GetCollaborationSigns -> Errore validazione parametri in ingresso, mappingName non valorizzato"), LogCategories);
return BadRequest("GetCollaborationSigns -> Errore validazione parametri in ingresso, mappingName non valorizzato");
}
WorkflowRepository repository = _unitOfWork.Repository <WorkflowRepository>().GetByInstanceId(workflowInstanceId);
if (repository == null)
{
_logger.WriteError(new LogMessage("Nessun repository trovato"), LogCategories);
return BadRequest("Nessun repository trovato");
}
IEnumerable <WorkflowRoleMapping> workflowRoleMappings;
if (string.IsNullOrEmpty(internalActivityId))
{
workflowRoleMappings = _unitOfWork.Repository <WorkflowRoleMapping>().GetByMappingTag(mappingName, repository.UniqueId);
}
else
{
workflowRoleMappings = _unitOfWork.Repository <WorkflowRoleMapping>().GetByMappingTag(mappingName, repository.UniqueId, internalActivityId);
}
ICollection <WorkflowAuthorization> workflowAuthorizations = _workflowAuthorizationService.GetAuthorizationsByMappings(workflowRoleMappings);
short incremental = 1;
foreach (WorkflowAuthorization workflowAuthorization in workflowAuthorizations)
{
DomainUserModel user = _security.GetUser(workflowAuthorization.Account);
CollaborationSignModel collaborationSign = _domainSignMapper.Map(user, new CollaborationSignModel());
collaborationSign.SignUser = workflowAuthorization.Account;
collaborationSign.Incremental = incremental++;
signers.Add(collaborationSign);
}
return Ok(signers);
}, _logger, LogCategories));
}
internal static Content Update(Content content)
{
var binding = content.WorkflowBinding;
var newContent = DefaultRepository.Update <Content, ContentDAL>(content);
binding.SetContent(newContent);
WorkflowRepository.UpdateContentWorkflowBind(binding);
// Обновить свойства у агрегированных контентов
foreach (var aggregated in content.AggregatedContents)
{
var localAggregated = aggregated;
localAggregated.AutoArchive = content.AutoArchive;
localAggregated = DefaultRepository.Update <Content, ContentDAL>(localAggregated);
binding.SetContent(localAggregated);
WorkflowRepository.UpdateContentWorkflowBind(binding);
}
return(GetById(newContent.Id));
}
internal static Content Save(Content content, bool createDefaultField)
{
var binding = content.WorkflowBinding;
FieldRepository.ChangeCreateFieldsTriggerState(false);
DefaultRepository.TurnIdentityInsertOn(EntityTypeCode.Content, content);
var newContent = DefaultRepository.Save <Content, ContentDAL>(content);
DefaultRepository.TurnIdentityInsertOff(EntityTypeCode.Content);
FieldRepository.ChangeCreateFieldsTriggerState(true);
if (createDefaultField)
{
CreateDefaultField(newContent, content.ForceFieldIds);
}
binding.SetContent(newContent);
WorkflowRepository.UpdateContentWorkflowBind(binding);
return(GetById(newContent.Id));
}
public async Task GetDescriptionEntityFieldStringsInWorkflowAsync(StringBuilder strFile, Guid idWorkflow)
{
try
{
var repository = new WorkflowRepository(_service);
var workflow = await repository.GetByIdAsync(idWorkflow, ColumnSetInstances.AllColumns);
string xmlContent = ContentComparerHelper.RemoveDiacritics(workflow.Xaml);
var doc = XElement.Parse(xmlContent);
var handler = new WorkflowUsedEntitiesHandler();
strFile
.AppendFormat("Entity: {0}", workflow.PrimaryEntity).AppendLine()
.AppendFormat("Category: {0}", workflow.FormattedValues[Workflow.Schema.Attributes.category]).AppendLine()
.AppendFormat("Name: {0}", workflow.Name).AppendLine()
.AppendFormat("Url: {0}", _service.UrlGenerator.GetSolutionComponentUrl(ComponentType.Workflow, idWorkflow)).AppendLine()
.AppendLine()
.AppendLine()
.AppendLine()
;
var strings = await handler.GetWorkflowStringsEntityFieldsAsync(doc);
Dictionary <Guid, List <WorkflowEntityFieldString> > workflowsWithStrings = new Dictionary <Guid, List <WorkflowEntityFieldString> >();
if (strings.Any())
{
workflowsWithStrings.Add(idWorkflow, strings);
}
await FillDescriptionEntityFieldStrings(strFile, workflowsWithStrings);
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(_service.ConnectionData, ex);
}
}
public bool UpdateWorkflow(WorkflowDC workflow)
{
Enforce.ArgumentNotNull(workflow, "workflow");
Enforce.ArgumentNotNull(workflow.Id, "workflow.Id");
Enforce.ArgumentNotNull(workflow.StartState, "workflow.StartState");
Enforce.ArgumentNotNull(workflow.DisplayName, "workflow.DisplayName");
Enforce.ArgumentGreaterThanZero(workflow.States.Count, "workflow.States");
var validator = new WorkflowValidation();
ValidationResult results = validator.Validate(workflow);
IRepositoryHelper repoHelper = new RepositoryHelper(_connectionString);
try
{
var unitOfWork = new JsonUnitOfWork(_connectionString);
var wfRepo = new WorkflowRepository(unitOfWork);
var workflowUpdated = wfRepo.Update(workflow.GetWorkflow());
var stateRepo = new StateRepository(unitOfWork);
stateRepo.SetWorkflowStates(workflow.Id, workflow.States.ToRepoList());
var actRepo = new StateActivityRepository(unitOfWork);
actRepo.SetWorkflowStates(workflow.Id, workflow.Activities.ToRepoList());
var tranRepo = new StateTransitionRepository(unitOfWork);
tranRepo.SetWorkflowStates(workflow.Id, workflow.Transitions.ToRepoList());
repoHelper.GetUnitOfWork().SaveChanges();
}
catch (Exception ex)
{
var message = ex.Message;
throw;
}
return(true);
}
protected override IQueryOver <WorkflowActivity, WorkflowActivity> MappingProjection(IQueryOver <WorkflowActivity, WorkflowActivity> queryOver)
{
WorkflowActivityResult workflowResult = null;
WorkflowRepository workflowRepository = null;
WorkflowInstance workflowInstance = null;
queryOver
.SelectList(list => list
// Mappatura degli oggetti Desk
.Select(x => x.Id).WithAlias(() => workflowResult.WorkflowActivityId)
.Select(x => x.Name).WithAlias(() => workflowResult.WorkflowActivityName)
.Select(x => x.Status).WithAlias(() => workflowResult.WorkflowActivityStatus)
.Select(x => x.ActivityType).WithAlias(() => workflowResult.WorkflowActivityType)
.Select(x => x.RegistrationDate).WithAlias(() => workflowResult.WorkflowActivityPublicationDate)
.Select(x => x.RegistrationUser).WithAlias(() => workflowResult.WorkflowActivityRequestorUser)
.Select(x => x.LastChangedDate).WithAlias(() => workflowResult.WorkflowActivityLastChangedDate)
.Select(x => x.Subject).WithAlias(() => workflowResult.WorkflowSubject)
// Mappatura degli oggetti WorkflowRepository
.Select(() => workflowRepository.Name).WithAlias(() => workflowResult.WorkflowRepositoryName)
.Select(() => workflowInstance.Id).WithAlias(() => workflowResult.WorkflowInstanceId)
);
return(queryOver);
}
private string GetSolutionComponentRelativeUrl(ComponentType componentType, Guid objectId)
{
switch (componentType)
{
case ComponentType.SavedQueryVisualization:
{
var respositorySolution = new SolutionRepository(this._service);
var chart = _service.RetrieveByQuery <SavedQueryVisualization>(SavedQueryVisualization.EntityLogicalName, objectId, new ColumnSet(SavedQueryVisualization.Schema.Attributes.primaryentitytypecode));
if (chart != null && !string.IsNullOrEmpty(chart.PrimaryEntityTypeCode))
{
if ((this._service.ConnectionData.EntitiesIntellisenseData?.Entities?.ContainsKey(chart.PrimaryEntityTypeCode)).GetValueOrDefault())
{
var linkedEntityObjectCode = this._service.ConnectionData.EntitiesIntellisenseData.Entities[chart.PrimaryEntityTypeCode].ObjectTypeCode;
if (linkedEntityObjectCode.HasValue)
{
return($"/main.aspx?appSolutionId=%7b{Solution.Schema.InstancesUniqueId.DefaultId}%7d&extraqs=etc%3d{linkedEntityObjectCode}%26id%3d%7b{objectId}%7d&pagetype=vizdesigner");
}
}
}
}
break;
case ComponentType.SystemForm:
{
var respositorySolution = new SolutionRepository(this._service);
var systemform = _service.RetrieveByQuery <SystemForm>(SystemForm.EntityLogicalName, objectId, new ColumnSet(SystemForm.Schema.Attributes.type, SystemForm.Schema.Attributes.objecttypecode));
if (systemform != null && systemform.Type != null)
{
if (systemform.Type.Value == (int)SystemForm.Schema.OptionSets.type.Task_Flow_Form_9)
{
var workflowRepository = new WorkflowRepository(_service);
var linkedWorkflow = workflowRepository.FindLinkedWorkflow(systemform.Id, ColumnSetInstances.None);
if (linkedWorkflow != null)
{
return(this.GetSolutionComponentRelativeUrl(ComponentType.Workflow, linkedWorkflow.Id));
}
}
else
{
return(_service.ConnectionData.GetSystemFormRelativeUrl(systemform.ObjectTypeCode, systemform.Id, systemform.Type.Value));
}
}
}
break;
case ComponentType.SiteMap:
{
var respositorySolution = new SolutionRepository(this._service);
//designer/sitemap/FD140AAF-4DF4-11DD-BD17-0019B9312238/39983702-960A-E711-80DD-00155D018C04#/SiteMapHome/39983702-960a-e711-80dd-00155d018c04
return($"/designer/sitemap/{Solution.Schema.InstancesUniqueId.DefaultId}/{objectId}#/SiteMapHome/{objectId}");
}
case ComponentType.AttributeMap:
{
var attributeMap = _service.RetrieveByQuery <AttributeMap>(AttributeMap.EntityLogicalName, objectId, new ColumnSet(AttributeMap.Schema.Attributes.entitymapid));
if (attributeMap != null && attributeMap.EntityMapId != null)
{
return(this.GetSolutionComponentRelativeUrl(ComponentType.EntityMap, attributeMap.EntityMapId.Id));
}
}
break;
case ComponentType.DisplayStringMap:
{
var displayMap = _service.RetrieveByQuery <DisplayStringMap>(DisplayStringMap.EntityLogicalName, objectId, new ColumnSet(DisplayStringMap.Schema.Attributes.displaystringid));
if (displayMap != null && displayMap.DisplayStringId.HasValue)
{
return(this.GetSolutionComponentRelativeUrl(ComponentType.DisplayString, displayMap.DisplayStringId.Value));
}
}
break;
case ComponentType.RolePrivileges:
{
var entity = _service.RetrieveByQuery <RolePrivileges>(RolePrivileges.EntityLogicalName, objectId, new ColumnSet(RolePrivileges.Schema.Attributes.roleid));
if (entity != null && entity.RoleId.HasValue)
{
return(this.GetSolutionComponentRelativeUrl(ComponentType.Role, entity.RoleId.Value));
}
}
break;
case ComponentType.FieldPermission:
{
var entity = _service.RetrieveByQuery <FieldPermission>(FieldPermission.EntityLogicalName, objectId, new ColumnSet(FieldPermission.Schema.Attributes.fieldsecurityprofileid));
if (entity != null && entity.FieldSecurityProfileId != null)
{
return(this.GetSolutionComponentRelativeUrl(ComponentType.FieldSecurityProfile, entity.FieldSecurityProfileId.Id));
}
}
break;
case ComponentType.ReportEntity:
{
var entity = _service.RetrieveByQuery <ReportEntity>(ReportEntity.EntityLogicalName, objectId, new ColumnSet(ReportEntity.Schema.Attributes.reportid));
if (entity != null && entity.ReportId != null)
{
return(this.GetSolutionComponentRelativeUrl(ComponentType.Report, entity.ReportId.Id));
}
}
break;
case ComponentType.ReportCategory:
{
var entity = _service.RetrieveByQuery <ReportCategory>(ReportCategory.EntityLogicalName, objectId, new ColumnSet(ReportCategory.Schema.Attributes.reportid));
if (entity != null && entity.ReportId != null)
{
return(this.GetSolutionComponentRelativeUrl(ComponentType.Report, entity.ReportId.Id));
}
}
break;
case ComponentType.ReportVisibility:
{
var entity = _service.RetrieveByQuery <ReportVisibility>(ReportVisibility.EntityLogicalName, objectId, new ColumnSet(ReportVisibility.Schema.Attributes.reportid));
if (entity != null && entity.ReportId != null)
{
return(this.GetSolutionComponentRelativeUrl(ComponentType.Report, entity.ReportId.Id));
}
}
break;
case ComponentType.AppModule:
{
var respositorySolution = new SolutionRepository(this._service);
// /designer/app/47FB3607-13DA-E811-8114-001DD8B71D68/7A536683-A60D-E811-8105-001DD8B71D68#/AppDesignerCanvas/7a536683-a60d-e811-8105-001dd8b71d68
return($"/designer/app/{Solution.Schema.InstancesUniqueId.DefaultId}/{objectId}#/AppDesignerCanvas/{objectId}");
}
case ComponentType.AppModuleRoles:
{
var appModuleRoles = _service.RetrieveByQuery <AppModuleRoles>(AppModuleRoles.EntityLogicalName, objectId, new ColumnSet(AppModuleRoles.Schema.Attributes.appmoduleid));
if (appModuleRoles != null && appModuleRoles.AppModuleId != null)
{
return(this.GetSolutionComponentRelativeUrl(ComponentType.AppModule, appModuleRoles.AppModuleId.Id));
}
}
break;
//case ComponentType.RibbonCommand:
// return $"";
//case ComponentType.RibbonContextGroup:
// return $"";
//case ComponentType.RibbonCustomization:
// return $"";
//case ComponentType.RibbonRule:
// return $"";
//case ComponentType.RibbonTabToCommandMap:
// return $"";
//case ComponentType.RibbonDiff:
// return $"";
//case ComponentType.SLAItem:
// return $"";
//case ComponentType.Relationship:
// return $"";
//case ComponentType.AttributePicklistValue:
// return $"";
//case ComponentType.AttributeLookupValue:
// return $"";
//case ComponentType.ViewAttribute:
// return $"";
//case ComponentType.LocalizedLabel:
// return $"";
//case ComponentType.RelationshipExtraCondition:
// return $"";
//case ComponentType.EntityRelationshipRole:
// return $"";
//case ComponentType.EntityRelationshipRelationships:
// return $"";
//case ComponentType.ManagedProperty:
// return $"";
//case ComponentType.Form:
// return $"";
//case ComponentType.Organization:
// return $"";
//case ComponentType.Attachment:
// return $"";
//case ComponentType.PluginType:
// return $"";
//case ComponentType.PluginAssembly:
// return $"";
//case ComponentType.SDKMessageProcessingStep:
// return $"";
//case ComponentType.SDKMessageProcessingStepImage:
// return $"";
//case ComponentType.ServiceEndpoint:
// return $"";
//case ComponentType.RoutingRule:
// return $"";
//case ComponentType.RoutingRuleItem:
// return $"";
//case ComponentType.ConvertRule:
// return $"";
//case ComponentType.ConvertRuleItem:
// return $"";
//case ComponentType.HierarchyRule:
// return $"";
//case ComponentType.MobileOfflineProfileItem:
// return $"";
//case ComponentType.SimilarityRule:
// return $"";
}
return(this._service.ConnectionData.GetSolutionComponentRelativeUrl(componentType, objectId));
}
private async Task <WorkflowResult> StartWorkflowJson(WorkflowStart content)
{
WorkflowResult validationResult = new WorkflowResult();
WorkflowRepository workflowRepository = _unitOfWork.Repository <WorkflowRepository>().GetByName(content.WorkflowName);
if (workflowRepository == null)
{
throw new DSWValidationException("Evaluate start workflow validation error",
new List <ValidationMessageModel>()
{
new ValidationMessageModel
{
Key = "WorkflowStart",
Message = $"Impossibile avviare il workflow '{content.WorkflowName}' in quanto non esiste nel repositories dei workflow validi."
}
}, null, DSWExceptionCode.VA_RulesetValidation);
}
WorkflowInstance workflowInstance = new WorkflowInstance()
{
Status = WorkflowStatus.Todo,
WorkflowRepository = workflowRepository,
Json = workflowRepository.Json,
Subject = workflowRepository.Name
};
WorkflowProperty prop;
foreach (KeyValuePair <string, WorkflowArgument> item in content.Arguments)
{
prop = _workflowArgumentMapper.Map(item.Value, new WorkflowProperty());
prop.WorkflowType = WorkflowType.Workflow;
workflowInstance.WorkflowProperties.Add(prop);
}
WorkflowProperty _dsw_p_WorkflowStartMotivationRequired = workflowInstance.WorkflowProperties.SingleOrDefault(f => f.Name == WorkflowPropertyHelper.DSW_PROPERTY_WORKFLOW_START_MOTIVATION_REQUIRED);
WorkflowProperty _dsw_p_InstanceSubject = workflowInstance.WorkflowProperties.SingleOrDefault(f => f.Name == WorkflowPropertyHelper.DSW_PROPERTY_INSTANCE_SUBJECT);
WorkflowProperty _dsw_v_Workflow_ActiveInstanceSubjectUnique = workflowInstance.WorkflowProperties.SingleOrDefault(f => f.Name == WorkflowPropertyHelper.DSW_VALIDATION_INSTANCE_ACTIVE_SUBJECT_UNIQUE);
WorkflowProperty _dsw_v_Workflow_StartValidations = workflowInstance.WorkflowProperties.SingleOrDefault(f => f.Name == WorkflowPropertyHelper.DSW_VALIDATION_WORKFLOW_START);
WorkflowProperty _dsw_p_ReferenceModel = workflowInstance.WorkflowProperties.SingleOrDefault(f => f.Name == WorkflowPropertyHelper.DSW_PROPERTY_REFERENCE_MODEL);
if (_dsw_v_Workflow_StartValidations != null && !string.IsNullOrEmpty(_dsw_v_Workflow_StartValidations.ValueString))
{
Dictionary <DSWEnvironmentType, WorkflowRuleDefinition> deserializedWorkflowStartValidation = JsonConvert.DeserializeObject <Dictionary <DSWEnvironmentType, WorkflowRuleDefinition> >(_dsw_v_Workflow_StartValidations.ValueString);
Guid fascicleId = JsonConvert.DeserializeObject <WorkflowReferenceModel>(_dsw_p_ReferenceModel.ValueString).ReferenceId;
#region Intermediate Validations
if (!(deserializedWorkflowStartValidation is Dictionary <DSWEnvironmentType, WorkflowRuleDefinition>))
{
throw new DSWValidationException("Evaluate start workflow validation error",
new List <ValidationMessageModel>()
{
new ValidationMessageModel
{
Key = "WorkflowStart",
Message = $"Impossibile avviare il workflow '{content.WorkflowName}' in quanto le definizioni delle regole di avvio non sono valide (struttura non valida)."
}
}, null, DSWExceptionCode.VA_RulesetValidation);
}
if (deserializedWorkflowStartValidation.Keys.FirstOrDefault().ToString() != EnumHelper.GetDescription(DSWEnvironmentType.Fascicle))
{
throw new DSWValidationException("Evaluate start workflow validation error",
new List <ValidationMessageModel>()
{
new ValidationMessageModel
{
Key = "WorkflowStart",
Message = $"Impossibile avviare il workflow '{content.WorkflowName}' in quanto il motore supporta definizioni solo per il modulo Fascicoli (environment non supportato)."
}
}, null, DSWExceptionCode.VA_RulesetValidation);
}
#endregion
List <ValidationMessageModel> errorResult = new List <ValidationMessageModel>();
ICollection <WorkflowRule> deserializedWorkflowRules = deserializedWorkflowStartValidation[DSWEnvironmentType.Fascicle].Rules;
await ValidateWorkflowRules(fascicleId, errorResult, deserializedWorkflowRules);
}
if (_dsw_p_InstanceSubject != null)
{
workflowInstance.Subject = _dsw_p_InstanceSubject.ValueString;
_logger.WriteDebug(new LogMessage($"SET INSTANCE SUBJECT: {workflowInstance.Subject}"), LogCategories);
}
if (_dsw_p_WorkflowStartMotivationRequired != null && _dsw_p_WorkflowStartMotivationRequired.ValueBoolean.HasValue && _dsw_p_WorkflowStartMotivationRequired.ValueBoolean.Value)
{
WorkflowProperty dsw_p_Subject = workflowInstance.WorkflowProperties.SingleOrDefault(f => f.Name == WorkflowPropertyHelper.DSW_PROPERTY_SUBJECT);
if (dsw_p_Subject == null || string.IsNullOrEmpty(dsw_p_Subject.ValueString))
{
throw new DSWValidationException("Evaluate start workflow validation error",
new List <ValidationMessageModel>()
{
new ValidationMessageModel
{
Key = "WorkflowStart",
Message = $"Impossibile avviare il flusso di lavoro se non è stata fornita una motivazione"
}
}, null, DSWExceptionCode.VA_RulesetValidation);
}
}
if (_dsw_v_Workflow_ActiveInstanceSubjectUnique != null && _dsw_v_Workflow_ActiveInstanceSubjectUnique.ValueBoolean.HasValue && _dsw_v_Workflow_ActiveInstanceSubjectUnique.ValueBoolean.Value)
{
if (_unitOfWork.Repository <WorkflowInstance>().CountActiveInstances(workflowInstance.WorkflowRepository.UniqueId, workflowInstance.Subject) > 0)
{
throw new DSWValidationException("Evaluate start workflow validation error",
new List <ValidationMessageModel>()
{
new ValidationMessageModel
{
Key = "WorkflowStart",
Message = $"Impossibile avviare un nuovo flusso di lavoro in cui l'oggetto '{workflowInstance.Subject}' è stato come unico attivo. Completare i restanti flussi di lavoro attivi."
}
}, null, DSWExceptionCode.VA_RulesetValidation);
}
}
_unitOfWork.BeginTransaction();
Guid instanceId = Guid.NewGuid();
workflowInstance = await _workflowInstanceService.CreateAsync(workflowInstance);
await PopulateActivityAsync(workflowInstance, instanceId, workflowInstance.WorkflowRepository,
workflowInstance.WorkflowProperties.Where(f => !f.Name.Equals(WorkflowPropertyHelper.DSW_ACTION_ACTIVITY_MANUAL_COMPLETE)));
bool result = await _unitOfWork.SaveAsync();
_unitOfWork.BeginTransaction();
workflowInstance.Status = WorkflowStatus.Progress;
if (!workflowInstance.InstanceId.HasValue)
{
workflowInstance.InstanceId = instanceId;
}
workflowInstance = await _workflowInstanceService.UpdateAsync(workflowInstance);
result = await _unitOfWork.SaveAsync();
validationResult.InstanceId = workflowInstance.InstanceId;
validationResult.IsValid = true;
_logger.WriteInfo(new LogMessage($"Assing workflowInstance.InstanceId [{workflowInstance.InstanceId}] for {workflowInstance.WorkflowRepository.Name}"), LogCategories);
return(validationResult);
}
private async Task GetDescriptionWithUsedEntitiesInSolutionWorkflows(StringBuilder strFile, Guid idSolution)
{
try
{
var repositorySolution = new SolutionRepository(_service);
var solution = await repositorySolution.GetSolutionByIdAsync(idSolution);
this._iWriteToOutput.WriteToOutput(_service.ConnectionData, string.Empty);
this._iWriteToOutput.WriteToOutput(_service.ConnectionData, string.Empty);
strFile.AppendLine(this._iWriteToOutput.WriteToOutputStartOperation(_service.ConnectionData, Properties.OperationNames.AnalyzingSolutionWorkflowsFormat2, _service.ConnectionData.Name, solution.UniqueName));
SolutionComponentRepository repository = new SolutionComponentRepository(_service);
var repositoryWorkflow = new WorkflowRepository(_service);
HashSet <Guid> workflowsWithEntities = new HashSet <Guid>();
Dictionary <EntityReference, HashSet <Guid> > list = new Dictionary <EntityReference, HashSet <Guid> >();
var handler = new WorkflowUsedEntitiesHandler();
{
var components = await repository.GetSolutionComponentsByTypeAsync(solution.Id, ComponentType.Workflow, new ColumnSet(SolutionComponent.Schema.Attributes.objectid));
_descriptor.GetEntities <Workflow>((int)ComponentType.Workflow, components.Select(c => c.ObjectId));
var workflows = await repositoryWorkflow.GetListByIdListAsync(components.Select(en => en.ObjectId.Value), new ColumnSet(Workflow.Schema.Attributes.xaml));
foreach (var item in workflows)
{
if (string.IsNullOrEmpty(item.Xaml))
{
continue;
}
var xmlContent = ContentCoparerHelper.RemoveDiacritics(item.Xaml);
var doc = XElement.Parse(xmlContent);
var coll = await handler.GetWorkflowUsedEntitiesAsync(doc);
if (coll.Count > 0)
{
workflowsWithEntities.Add(item.Id);
foreach (var entityRef in coll)
{
HashSet <Guid> linkedWorkflows = null;
if (list.ContainsKey(entityRef))
{
linkedWorkflows = list[entityRef];
}
else
{
list[entityRef] = linkedWorkflows = new HashSet <Guid>();
}
linkedWorkflows.Add(item.Id);
}
}
}
}
{
var components = await repository.GetSolutionComponentsByTypeAsync(solution.Id, ComponentType.Entity, new ColumnSet(SolutionComponent.Schema.Attributes.objectid));
var listMetadata = _descriptor.MetadataSource.GetEntityMetadataList(components.Where(e => e.ObjectId.HasValue).Select(e => e.ObjectId.Value));
foreach (var entityMetadata in listMetadata)
{
var workflows = await repositoryWorkflow.GetListAsync(entityMetadata.LogicalName, (int)Workflow.Schema.OptionSets.category.Business_Rule_2, null, new ColumnSet(Workflow.Schema.Attributes.xaml));
foreach (var item in workflows)
{
if (!string.IsNullOrEmpty(item.Xaml) && !workflowsWithEntities.Contains(item.Id))
{
var xmlContent = ContentCoparerHelper.RemoveDiacritics(item.Xaml);
var doc = XElement.Parse(xmlContent);
var coll = await handler.GetWorkflowUsedEntitiesAsync(doc);
if (coll.Count > 0)
{
workflowsWithEntities.Add(item.Id);
foreach (var entityRef in coll)
{
HashSet <Guid> linkedWorkflows = null;
if (list.ContainsKey(entityRef))
{
linkedWorkflows = list[entityRef];
}
else
{
list[entityRef] = linkedWorkflows = new HashSet <Guid>();
}
linkedWorkflows.Add(item.Id);
}
}
}
}
}
}
await FillDescriptionUsedEntities(strFile, workflowsWithEntities, list);
strFile.AppendLine(this._iWriteToOutput.WriteToOutputEndOperation(_service.ConnectionData, Properties.OperationNames.AnalyzingSolutionWorkflowsFormat2, _service.ConnectionData.Name, solution.UniqueName));
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(_service.ConnectionData, ex);
}
}
public static IEnumerable <Workflow> GetSiteWorkflows(int siteId)
{
return(WorkflowRepository.GetSiteWorkflows(siteId));
}
public Workflow SaveWorkflowProperties(Workflow workflow)
{
var result = WorkflowRepository.SaveProperties(workflow);
return(result);
}
public IEnumerable <int> GetBindedContetnsIds(int workflowId) => WorkflowRepository.GetBindedContetnsIds(workflowId);
public Workflow UpdateProperties(Workflow workflow, IEnumerable <int> activeContentsIds)
{
workflow.BindWithContent(activeContentsIds);
return(WorkflowRepository.UpdateProperties(workflow));
}
private SBSFormModel()
{
this.GenerateMapOfProperties();
this.WorkflowRepository = WorkflowRepository.Instance;
}
public StatusType GetClosestStatus(int statusWeight) => WorkflowRepository.GetClosestStatus(WorkflowId, statusWeight);
public bool UseStatus(int statusTypeId) => WorkflowRepository.DoesWorkflowUseStatus(WorkflowId, statusTypeId);
private async Task GetDescriptionWithUsedNotExistsEntitiesInAllWorkflows(StringBuilder strFile)
{
try
{
this._iWriteToOutput.WriteToOutput(_service.ConnectionData, string.Empty);
this._iWriteToOutput.WriteToOutput(_service.ConnectionData, string.Empty);
strFile.AppendLine(this._iWriteToOutput.WriteToOutputStartOperation(_service.ConnectionData, Properties.OperationNames.AnalyzingWorkflowsFormat1, _service.ConnectionData.Name));
SolutionComponentRepository repository = new SolutionComponentRepository(_service);
HashSet <Guid> workflowsWithEntities = new HashSet <Guid>();
Dictionary <EntityReference, HashSet <Guid> > list = new Dictionary <EntityReference, HashSet <Guid> >();
var handler = new WorkflowUsedEntitiesHandler();
var repositoryWorkflow = new WorkflowRepository(_service);
{
var workflows = await repositoryWorkflow.GetListAsync(null, null, null, new ColumnSet(Workflow.Schema.Attributes.xaml));
_descriptor.GetEntities <Workflow>((int)ComponentType.Workflow, workflows.Select(c => c.Id));
foreach (var item in workflows)
{
var xmlContent = ContentCoparerHelper.RemoveDiacritics(item.Xaml);
var doc = XElement.Parse(xmlContent);
var coll = await handler.GetWorkflowUsedEntitiesAsync(doc);
if (coll.Count > 0)
{
workflowsWithEntities.Add(item.Id);
foreach (var entityRef in coll)
{
HashSet <Guid> linkedWorkflows = null;
if (list.ContainsKey(entityRef))
{
linkedWorkflows = list[entityRef];
}
else
{
list[entityRef] = linkedWorkflows = new HashSet <Guid>();
}
linkedWorkflows.Add(item.Id);
}
}
}
}
await FillDescriptionNotExistsEntities(strFile, workflowsWithEntities, list);
strFile.AppendLine(this._iWriteToOutput.WriteToOutputEndOperation(_service.ConnectionData, Properties.OperationNames.AnalyzingWorkflowsFormat1, _service.ConnectionData.Name));
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(_service.ConnectionData, ex);
}
}
public void SetUp()
{
_workflowRepository = new WorkflowRepository(Configuration);
}
public MessageResult Remove(int id)
{
WorkflowRepository.DeleteVeStyle(id);
return(null);
}
public async Task GetDescriptionEntitesAndAttributesInWorkflowAsync(StringBuilder strFile, Guid idWorkflow)
{
try
{
var repository = new WorkflowRepository(_service);
var workflow = await repository.GetByIdAsync(idWorkflow, new ColumnSet(true));
string xmlContent = ContentCoparerHelper.RemoveDiacritics(workflow.Xaml);
var doc = XElement.Parse(xmlContent);
var handler = new WorkflowUsedEntitiesHandler();
strFile
.AppendFormat("Entity: {0}", workflow.PrimaryEntity).AppendLine()
.AppendFormat("Category: {0}", workflow.FormattedValues[Workflow.Schema.Attributes.category]).AppendLine()
.AppendFormat("Name: {0}", workflow.Name).AppendLine()
.AppendFormat("Url: {0}", _service.UrlGenerator.GetSolutionComponentUrl(ComponentType.Workflow, idWorkflow)).AppendLine()
.AppendLine()
;
WorkflowAnalysis analysis = handler.GetWorkflowAnalysis(doc);
if (analysis.UsedEntityAttributes.Any())
{
strFile
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine(new string('-', 150))
.AppendLine()
.AppendLine()
.AppendLine()
;
var tableUsedAttributes = new FormatTextTableHandler();
tableUsedAttributes.SetHeader("Entity", "Attribute", "StepName");
foreach (var step in analysis.UsedEntityAttributes
.OrderBy(e => e.EntityName)
.ThenBy(e => e.Attribute)
.ThenBy(e => e.DisplayName)
)
{
tableUsedAttributes.AddLine(step.EntityName, step.Attribute, step.DisplayName);
}
strFile.AppendFormat("Used Attributes: {0}", analysis.UsedEntityAttributes.Count).AppendLine();
tableUsedAttributes.GetFormatedLines(false).ForEach(s => strFile.AppendLine(tabspacer + s));
}
if (analysis.CreateUpdateEntitySteps.Any())
{
strFile
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine(new string('-', 150))
.AppendLine()
.AppendLine()
.AppendLine()
;
strFile.AppendFormat("Created or Updated Entities {0}", analysis.CreateUpdateEntitySteps.Count).AppendLine();
foreach (var step in analysis.CreateUpdateEntitySteps)
{
strFile.AppendFormat("Entity {0} Operation {1} StepName {2} With Attributes {2}", step.EntityName, step.StepType, step.DisplayName, step.SetEntityPropertySteps.Count).AppendLine()
;
var tableUsedAttributes = new FormatTextTableHandler();
tableUsedAttributes.SetHeader("Attribute");
foreach (var stepSet in step.SetEntityPropertySteps
.OrderBy(e => e.EntityName)
.ThenBy(e => e.Attribute)
)
{
tableUsedAttributes.AddLine(stepSet.Attribute);
}
tableUsedAttributes.GetFormatedLines(false).ForEach(s => strFile.AppendLine(tabspacer + s));
strFile.AppendLine().AppendLine();
}
}
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(_service.ConnectionData, ex);
}
}
