private IEnumerable <ParameterDefinitionWithValue> GetPersistedProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
var persistenceParameters = processDefinition.PersistenceParameters.ToList();
var parameters = new List <ParameterDefinitionWithValue>(persistenceParameters.Count());
List <WorkflowProcessInstancePersistence> persistedParameters;
using (PredefinedTransactionScopes.ReadUncommittedSupressedScope)
{
using (var context = CreateContext())
{
persistedParameters =
context.WorkflowProcessInstancePersistences.Where(
wpip =>
wpip.ProcessId == processId).ToList();
}
}
foreach (var persistedParameter in persistedParameters)
{
var parameterDefinition = persistenceParameters.FirstOrDefault(p => p.Name == persistedParameter.ParameterName);
if (parameterDefinition == null)
{
parameterDefinition = ParameterDefinition.Create(persistedParameter.ParameterName, "System.String", ParameterPurpose.Persistence.ToString(), null);
}
parameters.Add(ParameterDefinition.Create(parameterDefinition, _runtime.DeserializeParameter(persistedParameter.Value, parameterDefinition.Type)));
}
return(parameters);
}
private async Task <RawDataInformation[]> ListRawDataByUuidList(RawDataEntity entity, string[] uuids, FilterCondition filter, CancellationToken cancellationToken = default(CancellationToken))
{
StringUuidTools.CheckUuids(entity, uuids);
var requestPath = $"rawData/{entity}";
var parameterDefinitions = new List <ParameterDefinition>();
if (filter != null)
{
var filterTree = filter.BuildFilterTree();
var filterString = new FilterTreeFormatter().FormatString(filterTree);
var filterParameter = ParameterDefinition.Create("filter", filterString);
parameterDefinitions.Add(filterParameter);
}
//Split into multiple parameter sets to limit uuid parameter lenght
var splitter = new ParameterSplitter(this, requestPath);
var collectionParameter = CollectionParameterFactory.Create("uuids", uuids);
var parameterSets = splitter.SplitAndMerge(collectionParameter, parameterDefinitions);
//Execute requests in parallel
var requests = parameterSets
.Select(set => RequestBuilder.CreateGet(requestPath, set.ToArray()))
.Select(request => _RestClient.Request <RawDataInformation[]>(request, cancellationToken));
var result = await Task.WhenAll(requests).ConfigureAwait(false);
return(result.SelectMany(r => r).ToArray());
}
/// <inheritdoc/>
public async Task ClearPart(Guid partUuid, IEnumerable <ClearPartKeepEntitiesDto> clearPartKeepEntities = null, CancellationToken cancellationToken = default)
{
var featureMatrix = await GetFeatureMatrixInternal(FetchBehavior.FetchIfNotCached, cancellationToken).ConfigureAwait(false);
if (!featureMatrix.SupportClearPart)
{
throw new OperationNotSupportedOnServerException(
"Clearing a part is not supported by this server.",
DataServiceFeatureMatrix.ClearPartMinVersion,
featureMatrix.CurrentInterfaceVersion);
}
if (clearPartKeepEntities != null)
{
var clearPartListString = clearPartKeepEntities.Select(p => p.ToString());
var keepRestriction = RestClientHelper.ToListString(clearPartListString);
var keepListParameter = ParameterDefinition.Create("keep", keepRestriction);
await _RestClient.Request(RequestBuilder.CreatePost($"parts/{partUuid}/clear", Payload.Empty, keepListParameter), cancellationToken).ConfigureAwait(false);
}
else
{
await _RestClient.Request(RequestBuilder.CreatePost($"parts/{partUuid}/clear", Payload.Empty), cancellationToken).ConfigureAwait(false);
}
}
/// <summary>
/// Fills persisted <see cref="ParameterPurpose.Persistence"/> parameters of the process
/// </summary>
/// <param name="processInstance">Instance of the process</param>
public void FillPersistedProcessParameters(ProcessInstance processInstance)
{
var persistenceParameters = processInstance.ProcessScheme.PersistenceParameters.ToList();
var parameters = new List <ParameterDefinitionWithValue>(persistenceParameters.Count());
var db = _connector.GetDatabase();
var persistedParametersValue = db.StringGet(GetKeyForProcessPersistence(processInstance.ProcessId));
if (!persistedParametersValue.HasValue)
{
return;
}
var persistedParameters = JsonConvert.DeserializeObject <Dictionary <string, string> >(persistedParametersValue);
foreach (var persistedParameter in persistedParameters)
{
var parameterDefinition = persistenceParameters.FirstOrDefault(p => p.Name == persistedParameter.Key);
if (parameterDefinition == null)
{
parameterDefinition = ParameterDefinition.Create(persistedParameter.Key, "System.String", ParameterPurpose.Persistence.ToString(), null);
}
parameters.Add(ParameterDefinition.Create(parameterDefinition, _runtime.DeserializeParameter(persistedParameter.Value, parameterDefinition.Type)));
}
processInstance.AddParameters(parameters);
}
private IEnumerable <ParameterDefinitionWithValue> GetPersistedProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
var persistenceParameters = processDefinition.PersistenceParameters.ToList();
var parameters = new List <ParameterDefinitionWithValue>(persistenceParameters.Count());
List <WorkflowProcessInstancePersistence> persistedParameters;
using (PredefinedTransactionScopes.ReadUncommittedSupressedScope)
{
using (var context = CreateContext())
{
persistedParameters =
context.WorkflowProcessInstancePersistences.Where(
wpip =>
wpip.ProcessId == processId &&
persistenceParameters.Select(pp => pp.Name).Contains(wpip.ParameterName)).ToList();
}
}
foreach (var persistedParameter in persistedParameters)
{
var parameterDefinition = persistenceParameters.Single(p => p.Name == persistedParameter.ParameterName);
parameters.Add(ParameterDefinition.Create(parameterDefinition, _runtime.DeserializeParameter(persistedParameter.Value, parameterDefinition.Type)));
}
return(parameters);
}
/// <summary>
/// Creates a <see cref="ParameterDefinition"/> list that represents this filter.
/// </summary>
public IEnumerable <ParameterDefinition> ToParameterDefinition()
{
var result = new List <ParameterDefinition>();
if (Depth.HasValue)
{
result.Add(ParameterDefinition.Create(DepthParamName, Depth.ToString()));
}
if (WithHistory)
{
result.Add(ParameterDefinition.Create(WithHistoryParamName, WithHistory.ToString()));
}
if (PartUuids != null && PartUuids.Length > 0)
{
result.Add(ParameterDefinition.Create(PartUuidsParamName, RestClientHelper.ConvertGuidListToString(PartUuids)));
}
if (RequestedPartAttributes != null && RequestedPartAttributes.AllAttributes != AllAttributeSelection.True && RequestedPartAttributes.Attributes != null)
{
result.Add(ParameterDefinition.Create(RequestedPartAttributesParamName, RestClientHelper.ConvertUInt16ListToString(RequestedPartAttributes.Attributes)));
}
if (RequestedCharacteristicAttributes != null && RequestedCharacteristicAttributes.AllAttributes != AllAttributeSelection.True && RequestedCharacteristicAttributes.Attributes != null)
{
result.Add(ParameterDefinition.Create(RequestedCharacteristicsAttributesParamName, RestClientHelper.ConvertUInt16ListToString(RequestedCharacteristicAttributes.Attributes)));
}
return(result);
}
private IEnumerable <ParameterDefinitionWithValue> GetPersistedProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
var persistenceParameters = processDefinition.PersistenceParameters.ToList();
var parameters = new List <ParameterDefinitionWithValue>(persistenceParameters.Count());
List <WorkflowProcessInstancePersistence> persistedParameters;
using (var session = Store.OpenSession())
{
var process = session.Load <WorkflowProcessInstance>(processId);
if (process != null && process.Persistence != null)
{
persistedParameters = process.Persistence;
}
else
{
return(parameters);
//persistedParameters = new List<WorkflowProcessInstancePersistence>();
}
}
foreach (var persistedParameter in persistedParameters)
{
var parameterDefinition = persistenceParameters.FirstOrDefault(p => p.Name == persistedParameter.ParameterName);
if (parameterDefinition == null)
{
parameterDefinition = ParameterDefinition.Create(persistedParameter.ParameterName, "System.String", ParameterPurpose.Persistence.ToString(), null);
}
parameters.Add(ParameterDefinition.Create(parameterDefinition, _runtime.DeserializeParameter(persistedParameter.Value, parameterDefinition.Type)));
}
return(parameters);
}
private List <ExecutionRequestParameters> FillExecutionRequestParameters(Guid processId, ProcessInstance processInstance, IEnumerable <TransitionDefinition> transitions)
{
var newExecutionParameters = new List <ExecutionRequestParameters>();
foreach (var transition in transitions)
{
var parametersLocal = ExecutionRequestParameters.Create(processInstance.ProcessId,
processInstance.ProcessParameters,
transition, true);
if (transition.Trigger.Type != TriggerType.Auto || transition.Restrictions.Count() > 0)
{
var actors = GetActors(processId, transition);
parametersLocal.AddParameterInContainer(
ParameterDefinition.Create(DefaultDefinitions.ParameterIdentityIds,
actors));
}
if (transition.Trigger.Type == TriggerType.Command)
{
parametersLocal.AddParameterInContainer(ParameterDefinition.Create(DefaultDefinitions.ParameterCurrentCommand, (object)transition.Trigger.Command.Name));
}
newExecutionParameters.Add(parametersLocal);
}
return(newExecutionParameters);
}
private IEnumerable <ParameterDefinitionWithValue> GetPersistedProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
List <ParameterDefinition> persistenceParameters = processDefinition.PersistenceParameters.ToList <ParameterDefinition>();
List <ParameterDefinitionWithValue> list = new List <ParameterDefinitionWithValue>(persistenceParameters.Count <ParameterDefinition>());
List <WorkflowProcessInstancePersistence> list2;
using (PredefinedTransactionScopes.ReadUncommittedSupressedScope)
{
using (WorkflowPersistenceModelDataContext workflowPersistenceModelDataContext = base.CreateContext())
{
list2 = (
from wpip in workflowPersistenceModelDataContext.WorkflowProcessInstancePersistences
where wpip.ProcessId == processId && (
from pp in persistenceParameters
select pp.Name).Contains(wpip.ParameterName)
select wpip).ToList <WorkflowProcessInstancePersistence>();
}
}
foreach (WorkflowProcessInstancePersistence persistedParameter in list2)
{
ParameterDefinition parameterDefinition = persistenceParameters.Single((ParameterDefinition p) => p.Name == persistedParameter.ParameterName);
list.Add(ParameterDefinition.Create(parameterDefinition, this.DeserializeParameter(persistedParameter.Value, parameterDefinition.Type)));
}
return(list);
}
private IEnumerable <ParameterDefinitionWithValue> GetPersistedProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
var persistenceParameters = processDefinition.PersistenceParameters.ToList();
var parameters = new List <ParameterDefinitionWithValue>(persistenceParameters.Count());
List <WorkflowProcessInstancePersistence> persistedParameters;
var dbcoll = Store.GetCollection <WorkflowProcessInstance>(MongoDBConstants.WorkflowProcessInstanceCollectionName);
var process = dbcoll.Find(x => x.Id == processId).FirstOrDefault();
if (process != null && process.Persistence != null)
{
persistedParameters = process.Persistence.ToList();
}
else
{
return(parameters);
//persistedParameters = new List<WorkflowProcessInstancePersistence>();
}
foreach (var persistedParameter in persistedParameters)
{
var parameterDefinition = persistenceParameters.FirstOrDefault(p => p.Name == persistedParameter.ParameterName);
if (parameterDefinition == null)
{
parameterDefinition = ParameterDefinition.Create(persistedParameter.ParameterName, typeof(UnknownParameterType), ParameterPurpose.Persistence);
parameters.Add(ParameterDefinition.Create(parameterDefinition, persistedParameter.Value));
}
else
{
parameters.Add(ParameterDefinition.Create(parameterDefinition, ParametersSerializer.Deserialize(persistedParameter.Value, parameterDefinition.Type)));
}
}
return(parameters);
}
private IEnumerable <ParameterDefinitionWithValue> GetPersistedProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
var persistenceParameters = processDefinition.PersistenceParameters.ToList();
var parameters = new List <ParameterDefinitionWithValue>(persistenceParameters.Count());
List <WorkflowProcessInstancePersistence> persistedParameters;
using (var session = Store.OpenSession())
{
var process = session.Load <WorkflowProcessInstance>(processId);
if (process != null && process.Persistence != null)
{
persistedParameters = process.Persistence.Where(WorkflowProcessInstancep => persistenceParameters.Select(pp => pp.Name).Contains(WorkflowProcessInstancep.ParameterName)).ToList();
}
else
{
persistedParameters = new List <WorkflowProcessInstancePersistence>();
}
}
foreach (var persistedParameter in persistedParameters)
{
var parameterDefinition = persistenceParameters.Single(p => p.Name == persistedParameter.ParameterName);
parameters.Add(ParameterDefinition.Create(parameterDefinition, _runtime.DeserializeParameter(persistedParameter.Value, parameterDefinition.Type)));
}
return(parameters);
}
private IEnumerable <ParameterDefinitionWithValue> GetPersistedProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
var persistenceParameters = processDefinition.PersistenceParameters.ToList();
var parameters = new List <ParameterDefinitionWithValue>(persistenceParameters.Count());
List <WorkflowProcessInstancePersistence> persistedParameters;
var dbcoll = Store.GetCollection <WorkflowProcessInstance>(MongoDBConstants.WorkflowProcessInstanceCollectionName);
{
var process = dbcoll.FindOneById(processId);
if (process != null && process.Persistence != null)
{
persistedParameters = process.Persistence.Where(WorkflowProcessInstancep => persistenceParameters.Select(pp => pp.Name).Contains(WorkflowProcessInstancep.ParameterName)).ToList();
}
else
{
persistedParameters = new List <WorkflowProcessInstancePersistence>();
}
}
foreach (var persistedParameter in persistedParameters)
{
var parameterDefinition = persistenceParameters.Single(p => p.Name == persistedParameter.ParameterName);
parameters.Add(ParameterDefinition.Create(parameterDefinition, _runtime.DeserializeParameter(persistedParameter.Value, parameterDefinition.Type)));
}
return(parameters);
}
private IEnumerable <ParameterDefinitionWithValue> GetPersistedProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
var persistenceParameters = processDefinition.PersistenceParameters.ToList();
var parameters = new List <ParameterDefinitionWithValue>(persistenceParameters.Count());
List <WorkflowProcessInstancePersistence> persistedParameters;
var dbcoll = Store.GetCollection <WorkflowProcessInstance>(MongoDBConstants.WorkflowProcessInstanceCollectionName);
var process = dbcoll.FindOneById(processId);
if (process != null && process.Persistence != null)
{
persistedParameters = process.Persistence.ToList();
}
else
{
persistedParameters = new List <WorkflowProcessInstancePersistence>();
}
foreach (var persistedParameter in persistedParameters)
{
var parameterDefinition = persistenceParameters.FirstOrDefault(p => p.Name == persistedParameter.ParameterName);
if (parameterDefinition == null)
{
parameterDefinition = ParameterDefinition.Create(persistedParameter.ParameterName, "System.String", ParameterPurpose.Persistence.ToString(), null);
}
parameters.Add(ParameterDefinition.Create(parameterDefinition, _runtime.DeserializeParameter(persistedParameter.Value, parameterDefinition.Type)));
}
return(parameters);
}
private IEnumerable <ParameterDefinitionWithValue> GetPersistedProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
var persistenceParameters = processDefinition.PersistenceParameters.ToList();
var parameters = new List <ParameterDefinitionWithValue>(persistenceParameters.Count());
List <WorkflowProcessInstancePersistence> persistedParameters;
using (var connection = new NpgsqlConnection(ConnectionString))
{
persistedParameters = WorkflowProcessInstancePersistence.SelectByProcessId(connection, processId).ToList();
}
foreach (var persistedParameter in persistedParameters)
{
var parameterDefinition = persistenceParameters.FirstOrDefault(p => p.Name == persistedParameter.ParameterName);
if (parameterDefinition == null)
{
parameterDefinition = ParameterDefinition.Create(persistedParameter.ParameterName, typeof(UnknownParameterType), ParameterPurpose.Persistence);
parameters.Add(ParameterDefinition.Create(parameterDefinition, persistedParameter.Value));
}
else
{
parameters.Add(ParameterDefinition.Create(parameterDefinition, ParametersSerializer.Deserialize(persistedParameter.Value, parameterDefinition.Type)));
}
}
return(parameters);
}
private async Task <DataMeasurementDto[]> GetMeasurementValuesSplitByMeasurement(PathInformationDto partPath, MeasurementValueFilterAttributesDto filter, CancellationToken cancellationToken)
{
var newFilter = filter.Clone();
newFilter.MeasurementUuids = null;
var parameter = CreateParameterDefinitions(partPath, newFilter);
parameter.Add(ParameterDefinition.Create(AbstractMeasurementFilterAttributesDto.MeasurementUuidsParamName, ""));
var requestRestriction = RequestBuilder.AppendParameters("values", parameter);
var targetSize = RestClientHelper.GetUriTargetSize(ServiceLocation, requestRestriction, MaxUriLength);
var result = new List <DataMeasurementDto>(filter.MeasurementUuids.Length);
foreach (var uuids in ArrayHelper.Split(filter.MeasurementUuids, targetSize, RestClientHelper.LengthOfListElementInUri))
{
newFilter.MeasurementUuids = uuids;
if (newFilter.CharacteristicsUuidList?.Length > 0)
{
result.AddRange(await GetMeasurementValuesSplitByCharacteristics(partPath, newFilter, cancellationToken).ConfigureAwait(false));
}
else
{
result.AddRange(await _RestClient.Request <DataMeasurementDto[]>(RequestBuilder.CreateGet("values", CreateParameterDefinitions(partPath, newFilter).ToArray()), cancellationToken).ConfigureAwait(false));
}
}
return(result.ToArray());
}
private IEnumerable <ParameterDefinitionWithValue> GetPersistedProcessParameters(Guid processId,
ProcessDefinition processDefinition)
{
var persistenceParameters = processDefinition.PersistenceParameters.ToList();
var parameters = new List <ParameterDefinitionWithValue>(persistenceParameters.Count());
List <WorkflowProcessInstancePersistence> persistedParameters;
var cache =
Store.GetOrCreateCache <Guid, WorkflowProcessInstance>(IgniteConstants.WorkflowProcessInstanceCacheName);
var process = cache.Get(processId);
if (process != null && process.Persistence != null)
{
persistedParameters = process.Persistence.ToList();
}
else
{
return(parameters);
//persistedParameters = new List<WorkflowProcessInstancePersistence>();
}
foreach (var persistedParameter in persistedParameters)
{
var parameterDefinition =
persistenceParameters.FirstOrDefault(p => p.Name == persistedParameter.ParameterName) ??
ParameterDefinition.Create(persistedParameter.ParameterName, "System.String",
ParameterPurpose.Persistence.ToString(), null);
parameters.Add(ParameterDefinition.Create(parameterDefinition,
_runtime.DeserializeParameter(persistedParameter.Value, parameterDefinition.Type)));
}
return(parameters);
}
private IEnumerable <ParameterDefinitionWithValue> GetPersistedProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
var persistenceParameters = processDefinition.PersistenceParameters.ToList();
var parameters = new List <ParameterDefinitionWithValue>(persistenceParameters.Count());
List <WorkflowProcessInstancePersistence> persistedParameters;
using (MySqlConnection connection = new MySqlConnection(ConnectionString))
{
persistedParameters = WorkflowProcessInstancePersistence.SelectByProcessId(connection, processId).ToList();
}
foreach (var persistedParameter in persistedParameters)
{
var parameterDefinition = persistenceParameters.FirstOrDefault(p => p.Name == persistedParameter.ParameterName);
if (parameterDefinition == null)
{
parameterDefinition = ParameterDefinition.Create(persistedParameter.ParameterName, "System.String", ParameterPurpose.Persistence.ToString(), null);
}
parameters.Add(ParameterDefinition.Create(parameterDefinition, _runtime.DeserializeParameter(persistedParameter.Value, parameterDefinition.Type)));
}
return(parameters);
}
private IEnumerable <ParameterDefinitionWithValue> GetSystemProcessParameters(Guid processId,
ProcessDefinition processDefinition)
{
var processInstance = GetProcessInstance(processId);
var systemParameters =
processDefinition.Parameters.Where(p => p.Purpose == ParameterPurpose.System).ToList();
var parameters = new List <ParameterDefinitionWithValue>(systemParameters.Count)
{
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterProcessId.Name),
processId),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterPreviousState.Name),
processInstance.PreviousState),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterCurrentState.Name),
processInstance.StateName),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterPreviousStateForDirect.Name),
processInstance.PreviousStateForDirect),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterPreviousStateForReverse.Name),
processInstance.PreviousStateForReverse),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterPreviousActivity.Name),
processInstance.PreviousActivity),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterCurrentActivity.Name),
processInstance.ActivityName),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterPreviousActivityForDirect.Name),
processInstance.PreviousActivityForDirect),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterPreviousActivityForReverse.Name),
processInstance.PreviousActivityForReverse),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterSchemeCode.Name),
processDefinition.Name),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterSchemeId.Name),
processInstance.SchemeId),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterIsPreExecution.Name),
false),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterParentProcessId.Name),
processInstance.ParentProcessId),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterRootProcessId.Name),
processInstance.RootProcessId),
ParameterDefinition.Create(
systemParameters.Single(sp => sp.Name == DefaultDefinitions.ParameterTenantId.Name),
processInstance.TenantId)
};
return(parameters);
}
/// <summary>
/// Creates a CollectionParameter that can be split.
/// </summary>
/// <param name="name">Name of the collection parameter, e.g. 'uuids'</param>
/// <param name="values">The separate values as string.</param>
/// <param name="toStringConverter">A function to convert the parameter list to a string</param>
internal CollectionParameterDefinition(string name, IEnumerable <T> values, Func <IEnumerable <T>, string> toStringConverter)
{
Name = name;
Values = values;
_ToStringConverter = toStringConverter;
Empty = ParameterDefinition.Create(Name, EmptyCollectionString);
}
public override IEnumerable <ActionDefinition> ParseActions(XElement schemeMedium, IEnumerable <ParameterDefinition> parameterDefinitions)
{
if (schemeMedium == null)
{
throw new ArgumentNullException("schemeMedium");
}
if (parameterDefinitions == null)
{
throw new ArgumentNullException("parameterDefinitions");
}
var actionElements = schemeMedium.SingleOrDefault("Actions");
if (actionElements == null)
{
throw new ArgumentNullException("");
}
var parameterDefinitionsList = parameterDefinitions.ToList();
var actions = new List <ActionDefinition>();
foreach (var element in actionElements.Elements().ToList())
{
var executeMethodElement = element.Elements("ExecuteMethod").Single();
var action = ActionDefinition.Create(GetName(element), GetType(executeMethodElement), GetMethodName(executeMethodElement));
var inputParameters = executeMethodElement.Elements("InputParameters").SingleOrDefault();
if (inputParameters != null)
{
foreach (var xmlInputParameter in inputParameters.Elements())
{
var parameterRef = parameterDefinitionsList.Single(pd => pd.Name == GetNameRef(xmlInputParameter));
var parameterForAction = ParameterDefinition.Create(parameterRef, GetOrder(xmlInputParameter));
action.AddInputParameterRef(parameterForAction);
}
}
var outputParameters = executeMethodElement.Elements("OutputParameters").SingleOrDefault();
if (outputParameters != null)
{
foreach (var xmlOutputParameter in outputParameters.Elements())
{
var parameterRef =
parameterDefinitionsList.Single(pd => pd.Name == GetNameRef(xmlOutputParameter));
var parameterForAction = ParameterDefinition.Create(parameterRef, GetOrder(xmlOutputParameter));
action.AddOutputParameterRef(parameterForAction);
}
}
actions.Add(action);
}
return(actions);
}
private void SetStateWithExecution(Guid identityId,
Guid impersonatedIdentityId,
IDictionary <string, object> parameters,
ActivityDefinition activityToSet,
ProcessInstance processInstance)
{
SetProcessNewStatus(processInstance, ProcessStatus.Running);
IEnumerable <TransitionDefinition> transitions;
try
{
PersistenceProvider.FillSystemProcessParameters(processInstance);
PersistenceProvider.FillPersistedProcessParameters(processInstance);
var parametersLocal = new List <ParameterDefinitionWithValue>();
foreach (var commandParameter in parameters)
{
var parameterDefinition = processInstance.ProcessScheme.GetParameterDefinition(commandParameter.Key);
if (parameterDefinition != null)
{
parametersLocal.Add(ParameterDefinition.Create(parameterDefinition, commandParameter.Value));
}
}
parametersLocal.Add(ParameterDefinition.Create(DefaultDefinitions.ParameterCurrentCommand,
(object)DefaultDefinitions.CommandSetState.Name));
parametersLocal.Add(ParameterDefinition.Create(DefaultDefinitions.ParameterIdentityId, identityId));
parametersLocal.Add(ParameterDefinition.Create(DefaultDefinitions.ParameterImpersonatedIdentityId,
impersonatedIdentityId));
parametersLocal.Add(ParameterDefinition.Create(DefaultDefinitions.ParameterSchemeId, processInstance.SchemeId));
parametersLocal.ForEach(processInstance.AddParameter);
}
catch (Exception)
{
SetProcessNewStatus(processInstance, ProcessStatus.Idled);
throw;
}
//TODO Убрать после обработки команд
try
{
Bus.QueueExecution(ExecutionRequestParameters.Create(processInstance.ProcessId,
processInstance.ProcessParameters,
activityToSet,
ConditionDefinition.Always));
}
catch (Exception ex)
{
Logger.Log.Error(string.Format("Workflow Id={0}", processInstance.ProcessId), ex);
SetProcessNewStatus(processInstance, ProcessStatus.Idled);
throw;
}
}
/// <summary>
/// Creates a <see cref="ParameterDefinition"/> list that represents this filter.
/// </summary>
public ParameterDefinition[] ToParameterDefinition()
{
var result = new List <ParameterDefinition>();
if (Deep)
{
result.Add(ParameterDefinition.Create(DeepParamName, Deep.ToString()));
}
if (LimitResult >= 0)
{
result.Add(ParameterDefinition.Create(LimitResultParamName, LimitResult.ToString()));
}
if (MeasurementUuids != null && MeasurementUuids.Length > 0)
{
result.Add(ParameterDefinition.Create(MeasurementUuidsParamName, RestClientHelper.ConvertGuidListToString(MeasurementUuids)));
}
if (RequestedMeasurementAttributes != null && RequestedMeasurementAttributes.AllAttributes != AllAttributeSelection.True && RequestedMeasurementAttributes.Attributes != null)
{
result.Add(ParameterDefinition.Create(RequestedMeasurementAttributesParamName, RestClientHelper.ConvertUInt16ListToString(RequestedMeasurementAttributes.Attributes)));
}
if (OrderBy != null && OrderBy.Length > 0)
{
result.Add(ParameterDefinition.Create(OrderByParamName, OrderByToString(OrderBy)));
}
if (SearchCondition != null)
{
result.Add(ParameterDefinition.Create(SearchConditionParamName, SearchConditionParser.GenericConditionToString(SearchCondition)));
}
if (Statistics != MeasurementStatistics.None)
{
result.Add(ParameterDefinition.Create(StatisticsParamName, Statistics.ToString()));
}
if (AggregationMeasurements != AggregationMeasurementSelection.Default)
{
result.Add(ParameterDefinition.Create(AggregationParamName, AggregationMeasurements.ToString()));
}
if (FromModificationDate.HasValue)
{
result.Add(ParameterDefinition.Create(FromModificationDateParamName, XmlConvert.ToString(FromModificationDate.Value, XmlDateTimeSerializationMode.RoundtripKind)));
}
if (ToModificationDate.HasValue)
{
result.Add(ParameterDefinition.Create(ToModificationDateParamName, XmlConvert.ToString(ToModificationDate.Value, XmlDateTimeSerializationMode.RoundtripKind)));
}
return(result.ToArray());
}
public override void RegisterFinal(ProcessDefinition pd, List <WorkflowBlock> blocks)
{
base.RegisterFinal(pd, blocks);
//transitions
var commands = this["Commands"] as List <SimpleCommand>;
if (commands != null)
{
var restrictions = new List <RestrictionDefinition>();
if (this["_actorRestrictions"] is ActorDefinition)
{
restrictions.Add(RestrictionDefinition.Create(RestrictionType.Allow, (ActorDefinition)this["_actorRestrictions"]));
}
foreach (var c in commands)
{
var pdCommand = pd.Commands.Where(pdc => pdc.Name == c.Name).FirstOrDefault();
if (pdCommand == null)
{
pdCommand = CommandDefinition.Create(c.Name);
ParameterDefinition pdParameterComment = pd.Parameters.Where(p => p.Name == "Comment").FirstOrDefault();
if (pdParameterComment == null)
{
pdParameterComment = ParameterDefinition.Create("Comment", typeof(string), ParameterPurpose.Temporary, null);
pd.Parameters.Add(pdParameterComment);
}
pdCommand.InputParameters.Add(new ParameterDefinitionReference()
{
Name = "Comment",
Parameter = pdParameterComment
});
pd.Commands.Add(pdCommand);
}
pd.Transitions.Add(new TransitionDefinition()
{
Name = string.Format("{0}_{1}_{2}", Name, c.ToBlock.Name, c.Name),
Classifier = c.Classifier,
From = (ActivityDefinition)this["_currentActivity"],
To = (ActivityDefinition)c.ToBlock["_currentActivity"],
Trigger = new TriggerDefinition(TriggerType.Command)
{
Command = pdCommand
},
Conditions = new List <ConditionDefinition>()
{
ConditionDefinition.Always
},
Restrictions = restrictions
});
}
}
}
/// <inheritdoc />
/// <exception cref="ArgumentNullException"><paramref name="characteristics"/> is <see langword="null"/>.</exception>
public Task UpdateCharacteristics(InspectionPlanCharacteristicDto[] characteristics, bool versioningEnabled = false, CancellationToken cancellationToken = default)
{
if (characteristics == null)
{
throw new ArgumentNullException(nameof(characteristics));
}
var parameter = ParameterDefinition.Create("versioningEnabled", versioningEnabled.ToString());
return(_RestClient.Request(RequestBuilder.CreatePut("characteristics", Payload.Create(characteristics), parameter), cancellationToken));
}
/// <inheritdoc />
/// <exception cref="ArgumentNullException"><paramref name="charPath"/> is <see langword="null"/>.</exception>
public Task DeleteCharacteristics(PathInformationDto charPath, CancellationToken cancellationToken = default)
{
if (charPath == null)
{
throw new ArgumentNullException(nameof(charPath));
}
var parameter = ParameterDefinition.Create("charPath", PathHelper.PathInformation2DatabaseString(charPath));
return(_RestClient.Request(RequestBuilder.CreateDelete("characteristics", parameter), cancellationToken));
}
/// <summary>
/// Parses inspection plan filter criterias to a <see cref="ParameterDefinition"/> list.
/// </summary>
/// <param name="partPath">Path of the part the query should be restricted by.</param>
/// <param name="partUuids">Uuids of the parts the query should be restricted by.</param>
/// <param name="charUuids">Uuids of the parts the query should be restricted by.</param>
/// <param name="depth">The depth determines how deep the response should be.</param>
/// <param name="requestedPartAttributes">Restricts the part attributes that are returned.</param>
/// <param name="requestedCharacteristicAttributes">Restricts the characteristic attributes that are returned.</param>
/// <param name="withHistory">Determines if the history should be returned.</param>
/// <returns></returns>
public static List <ParameterDefinition> ParseToParameter(PathInformationDto partPath = null, Guid[] partUuids = null, Guid[] charUuids = null, ushort?depth = null, AttributeSelector requestedPartAttributes = null, AttributeSelector requestedCharacteristicAttributes = null, bool withHistory = false)
{
var parameter = new List <ParameterDefinition>();
if (partPath != null)
{
parameter.Add(ParameterDefinition.Create("partPath", PathHelper.PathInformation2DatabaseString(partPath)));
}
if (depth.HasValue)
{
parameter.Add(ParameterDefinition.Create("depth", depth.ToString()));
}
if (withHistory)
{
parameter.Add(ParameterDefinition.Create("withHistory", true.ToString()));
}
if (partUuids != null && partUuids.Length > 0)
{
parameter.Add(ParameterDefinition.Create("partUuids", ConvertGuidListToString(partUuids)));
}
if (charUuids != null && charUuids.Length > 0)
{
parameter.Add(ParameterDefinition.Create("charUuids", ConvertGuidListToString(charUuids)));
}
if (requestedPartAttributes != null)
{
if (requestedPartAttributes.AllAttributes != AllAttributeSelectionDto.True && requestedPartAttributes.Attributes != null)
{
parameter.Add(ParameterDefinition.Create("requestedPartAttributes", ConvertUshortArrayToString(requestedPartAttributes.Attributes)));
}
else if (requestedPartAttributes.AllAttributes == AllAttributeSelectionDto.False)
{
parameter.Add(ParameterDefinition.Create("requestedPartAttributes", "None"));
}
}
if (requestedCharacteristicAttributes != null)
{
if (requestedCharacteristicAttributes.AllAttributes != AllAttributeSelectionDto.True && requestedCharacteristicAttributes.Attributes != null)
{
parameter.Add(ParameterDefinition.Create("requestedCharacteristicAttributes", ConvertUshortArrayToString(requestedCharacteristicAttributes.Attributes)));
}
else if (requestedCharacteristicAttributes.AllAttributes == AllAttributeSelectionDto.False)
{
parameter.Add(ParameterDefinition.Create("requestedCharacteristicAttributes", "None"));
}
}
return(parameter);
}
/// <inheritdoc />
public async Task DeleteCharacteristics(Guid[] charUuid, CancellationToken cancellationToken = default)
{
const string requestPath = "characteristics";
var targetSize = RestClientHelper.GetUriTargetSize(ServiceLocation, requestPath, MaxUriLength, ParameterDefinition.Create("charUuids", "{}"));
foreach (var uuidList in ArrayHelper.Split(charUuid, targetSize, RestClientHelper.LengthOfListElementInUri))
{
var uuidListParameter = ParameterDefinition.Create("charUuids", RestClientHelper.ConvertGuidListToString(uuidList));
await _RestClient.Request(RequestBuilder.CreateDelete(requestPath, uuidListParameter), cancellationToken).ConfigureAwait(false);
}
}
private void FillParameters(ProcessInstance instance, ExecutionResponseParametersComplete newParameters)
{
foreach (var parameter in newParameters.ParameterContainer)
{
var parameterDefinition = instance.ProcessScheme.GetNullableParameterDefinition(parameter.Name);
if (parameterDefinition != null)
{
var parameterDefinitionWithValue = ParameterDefinition.Create(parameterDefinition, parameter.Value);
instance.AddParameter(parameterDefinitionWithValue);
}
}
}
/// <inheritdoc />
public async Task DeleteMeasurementsByUuid(Guid[] measurementUuids, CancellationToken cancellationToken = default)
{
if (measurementUuids.Any())
{
var emptyParameter = new[] { ParameterDefinition.Create("measurementUuids", "") };
var requestRestriction = RequestBuilder.AppendParameters("measurements", emptyParameter);
var targetSize = RestClientHelper.GetUriTargetSize(ServiceLocation, requestRestriction, MaxUriLength);
foreach (var uuids in ArrayHelper.Split(measurementUuids, targetSize, RestClientHelper.LengthOfListElementInUri))
{
var parameter = ParameterDefinition.Create("measurementUuids", RestClientHelper.ConvertGuidListToString(uuids));
await _RestClient.Request(RequestBuilder.CreateDelete("measurements", parameter), cancellationToken).ConfigureAwait(false);
}
}
}
private Task <RawDataInformation[]> ListRawDataForAllEntities(RawDataEntity entity, [NotNull] FilterCondition filter, CancellationToken cancellationToken = default(CancellationToken))
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
var requestPath = $"rawData/{entity}";
var parameterDefinitionList = new List <ParameterDefinition>();
var filterTree = filter.BuildFilterTree();
var filterString = new FilterTreeFormatter().FormatString(filterTree);
var filterParameter = ParameterDefinition.Create("filter", filterString);
parameterDefinitionList.Add(filterParameter);
return(_RestClient.Request <RawDataInformation[]>(RequestBuilder.CreateGet(requestPath, parameterDefinitionList.ToArray()), cancellationToken));
}