private Guid CreateRepositoryMethod(
GenericManager genericManager,
string methodName,
RepositoryMethod.RepositoryMethodType type,
MethodParameter[] inputParameters,
MethodParameter outputParameter)
{
var content = new RepositoryMethodContent();
foreach (var item in inputParameters)
{
item.Direction = MethodParameter.ParameterDirection.Input;
}
if (outputParameter != null)
{
outputParameter.Direction = MethodParameter.ParameterDirection.Output;
content.Parameters.Add(outputParameter);
}
content.Parameters.AddRange(inputParameters);
var method = new RepositoryMethod()
{
Name = methodName,
RepositoryId = RepositoryEntityReference,
Type = new OptionSetValue((int)type),
Content = JsonParserService.StringfyWithTypes(content),
};
return(genericManager.Create(RepositoryMethod.LogicalName, Entity.EntityToDictionary(method)));
}
public void InvokeConstrainEntity <T>(T entity, RepositoryMethod method)
{
if (typeof(T) == typeof(User))
{
_userConstrainer.InvokeConstrain(entity as User, method);
}
}
private void UpdatedExecuteRepositoryMethodSentence(RepositoryMethod method)
{
var repositoryId = method.RepositoryId.Id;
var repository = Entity.DictionartyToEntity <Repository>(GenericManager.Retrieve(Repository.LogicalName, repositoryId).Values);
var schemaId = repository.SchemaId.Id;
var schema = Entity.DictionartyToEntity <Schema>(GenericManager.Retrieve(Schema.LogicalName, schemaId).Values);
var newSentence = new ExecuteRepositoryMethodSentence(schema.Name, repository.Name, method);
_view.RaiseUpdateUseCaseSentenceEvent(newSentence, BasicSentence);
}
public void InvokeConstrain(T entity, RepositoryMethod method)
{
if (_constrainerByRepoMethod.TryGetValue(method, out var constrainers))
{
var tasks = constrainers?.Select(z => z.Constrain(entity));
if (tasks != null)
{
Task.WhenAll(tasks).GetAwaiter().GetResult();
}
}
}
private Guid CreateDefaultZeroInputsViewRepositoryMethod(GenericManager genericManager, string methodName)
{
var content = new RepositoryMethodContent()
.AddDefaultOutputViewParameter();
var method = new RepositoryMethod()
{
Name = methodName,
Type = new OptionSetValue((int)RepositoryMethod.RepositoryMethodType.View),
RepositoryId = RepositoryEntityReference,
Content = JsonParserService.StringfyWithTypes(content),
};
return(genericManager.Create(RepositoryMethod.LogicalName, Entity.EntityToDictionary(method)));
}
public ExecuteRepositoryMethodSentence(
Domain domain,
Schema schema,
Repository repository,
RepositoryMethod method)
: base(SentenceName, SentenceDescription, SentenceType)
{
Domain = domain ?? throw new ArgumentNullException(nameof(domain));
Schema = schema ?? throw new ArgumentNullException(nameof(schema));
Repository = repository ?? throw new ArgumentNullException(nameof(repository));
Method = method ?? throw new ArgumentNullException(nameof(method));
AddValue(nameof(Domain), Domain);
AddValue(nameof(Schema), Schema);
AddValue(nameof(Repository), Repository);
AddValue(nameof(Method), Method);
AddInputContextParameter(method.InputParameters.ToArray());
AddOutputContextParameter(Method.OutputParameters.First());
}
public void ProcessData(RepositoryMethod regardingRepositoryMethod)
{
Name = regardingRepositoryMethod.Name;
DisplayName = $"Method {SchemaName}.{RepositoryName}.{regardingRepositoryMethod.Name}";
var repositoryMethod = JsonParserService.ObjectifyWithTypes <RepositoryMethodContent>
(regardingRepositoryMethod.Content);
foreach (var item in repositoryMethod.Parameters
.Where(k => k.Direction == Methods.MethodParameter.ParameterDirection.Input))
{
InputParameters.Add(item);
}
foreach (var item in repositoryMethod.Parameters
.Where(k => k.Direction == Methods.MethodParameter.ParameterDirection.Output))
{
OutputParameters.Add(item);
}
}
public ExecuteRepositoryMethodSentence(string schemaName, string repositoryName, RepositoryMethod repositoryMethod)
: this()
{
Type = SentenceType.ExecuteRepositoryMethod;
if (repositoryMethod == null)
{
throw new ArgumentNullException(nameof(repositoryMethod));
}
RepositoryMethodId = new EntityReferenceValue(repositoryMethod.Id, RepositoryMethod.LogicalName, repositoryMethod.Name);
RepositoryName = repositoryName;
SchemaName = schemaName;
Values.Add(nameof(SchemaName), schemaName);
Values.Add(nameof(RepositoryName), repositoryName);
Values.Add(nameof(RepositoryMethodId), RepositoryMethodId);
ProcessData(repositoryMethod);
}
