public Task <IActionResult> CreateAsync([FromBody] FieldsValueByUserFlow fieldsValueByUserFlow)
{
return(ExceptionBehaviorAsync
(
async() => ResultApi(await RepoBusinessRules.CreateAsync(fieldsValueByUserFlow).ConfigureAwait(false))
));
}
/// <summary>
/// CreateAsync
/// </summary>
/// <param name="fieldsValueByUserFlow"></param>
/// <returns>Is Create</returns>
public Task <bool> CreateAsync(FieldsValueByUserFlow fieldsValueByUserFlow)
{
var fieldsByUserFlow = SearchAsyncById(fieldsValueByUserFlow.IdFlow, fieldsValueByUserFlow.IdUser);
if (fieldsByUserFlow.Result == null)
{
ThrowExceptionFlowByUser();
}
if (!CheckContainsAllFields(fieldsValueByUserFlow, fieldsByUserFlow.Result))
{
ThrowExceptionCheckContainsAllFieldr();
}
if (!ValidType(fieldsValueByUserFlow))
{
ThrowExceptionCheckValueTypeByField();
}
if (!SaveFieldValueByUser(fieldsValueByUserFlow))
{
return(Task.FromResult
(
false
));
}
return(Task.FromResult
(
true
));
}
/// <summary>
/// Valid Type
/// </summary>
/// <param name="fieldsValueByUserFlow">fields Value By User Flow</param>
/// <returns>Is Valid Type</returns>
private bool ValidType(FieldsValueByUserFlow fieldsValueByUserFlow)
{
var result = true;
var fieldConnection = new Fields(this.RepositoryContext);
foreach (FieldsValue fieldsValue in fieldsValueByUserFlow.fieldsValue)
{
var field = fieldConnection.SearchAsync(x => x.Id.Equals(fieldsValue.Id));
if (field.Result == null)
{
ThrowExceptionField();
}
var strategy = new ValidationTypeFielStrategy(BuilderType.GetStratey(GetTypeField.GetTypeById(field.Result.IdTypeField ?? default)));
if (!strategy.Validate(new TypeField()
{
FieldValue = fieldsValue.Value
}))
{
result = false;
break;
}
}
return(result);
}
/// <summary>
/// Get Fields By User
/// </summary>
/// <param name="fieldsValueByUserFlow">fields Value By User Flow</param>
/// <param name="fieldsValue">fields Value</param>
/// <returns></returns>
private static Entities.FieldsByUser GetFieldsByUser(FieldsValueByUserFlow fieldsValueByUserFlow, FieldsValue fieldsValue)
{
return(new Entities.FieldsByUser()
{
IdUser = fieldsValueByUserFlow.IdUser,
IdField = fieldsValue.Id,
Value = fieldsValue.Value
});
}
/// <summary>
/// SaveField Value ByUser
/// </summary>
/// <param name="fieldsValueByUserFlow">fields Value ByUser Flow</param>
/// <returns>Is Save</returns>
private bool SaveFieldValueByUser(FieldsValueByUserFlow fieldsValueByUserFlow)
{
var result = true;
var fieldsByUser = new FieldsByUser(this.RepositoryContext);
foreach (FieldsValue fieldsValue in fieldsValueByUserFlow.fieldsValue)
{
var idFields = fieldsByUser.CreateAsync(GetFieldsByUser(fieldsValueByUserFlow, fieldsValue));
if (idFields.Result == null)
{
result = false;
break;
}
}
return(result);
}
/// <summary>
/// Check Contains All Fields
/// </summary>
/// <param name="fieldsValueByUserFlow">fields Value By User Flow</param>
/// <param name="result">result</param>
/// <returns>Is Check</returns>
private static bool CheckContainsAllFields(FieldsValueByUserFlow fieldsValueByUserFlow, Entities.Dto.FlowGeneral result)
{
var isValid = true;
foreach (StepsGeneral step in result.StepsGeneral)
{
foreach (FieldGeneral field in step.FieldGeneral)
{
var fieldFound = fieldsValueByUserFlow.fieldsValue.Where(x => x.Id.Equals(field.Id));
if (fieldFound.Count().Equals(0))
{
isValid = false;
break;
}
}
if (!isValid)
{
break;
}
}
return(isValid);
}
