public static ApiValidatedResult <string> ValidateAndFormat(string number, bool allowNationalNumberOnly, bool allowSmsTargetOnly)
{
if (string.IsNullOrWhiteSpace(number))
{
return(ApiValidatedResult <string> .Failure(ValidationErrorInputIsNullOrEmpty));
}
if (!IsPossibleNumber(number))
{
return(ApiValidatedResult <string> .Failure(ValidationErrorInputIsNotAPossiblePhoneNumber));
}
var parsedNumber = ParseAndValidate(number);
if (parsedNumber == null)
{
return(ApiValidatedResult <string> .Failure(ValidationErrorInputIsNotAValidPhoneNumber));
}
if (allowNationalNumberOnly && !IsNationalNumber(parsedNumber))
{
return(ApiValidatedResult <string> .Failure(ValidationErrorInputIsNotANationalNumber));
}
if (allowSmsTargetOnly && !CanReceiveSms(parsedNumber))
{
return(ApiValidatedResult <string> .Failure(ValidationErrorInputIsNotAValidSmsTarget));
}
return(ApiValidatedResult <string> .Ok(Format(parsedNumber)));
}
protected T CheckSuccess <T>(ApiValidatedResult <T> result)
{
Assert.NotNull(result);
Assert.True(result.Success);
return(result.Result);
}
protected IHttpActionResult ValidatedResult <T>(ApiValidatedResult <T> result)
{
if (result.Success)
{
return(Ok(result.Result));
}
return(new ValidationErrorResult(result, this));
}
public static async Task <ApiValidatedResult <string> > ToRawValidatedResult(this HttpResponseMessage response)
{
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
return(ApiValidatedResult <string> .Ok(content));
}
return(ApiValidatedResult <string> .Failure(await response.Content.ReadAsStringAsync()));
}
public static async Task <ApiValidatedResult <TResponse> > ToValidatedResult <TResponse>(this HttpResponseMessage response)
{
if (response.IsSuccessStatusCode)
{
var content = await response.DeserializeAsync <TResponse>();
return(ApiValidatedResult <TResponse> .Ok(content));
}
return(ApiValidatedResult <TResponse> .Failure(response.ToValidationError()));
}
public async Task <IActionResult> AddKafkaOutputChannel(KafkaOutputChannelAddRequest input)
{
Logger.LogDebug($"{nameof(OutputChannelController)} - {nameof(AddKafkaOutputChannel)} method called with this input: {input}");
var channel = Mapping.AutoMapper.Mapper.Map <OutputChannel>(input);
await _outputChannelLogic.Create(channel);
var output = Mapping.AutoMapper.Mapper.Map <KafkaOutputChannelAddResponse>(channel);
return(Ok(ApiValidatedResult <KafkaOutputChannelAddResponse> .Ok(output)));
}
public async Task <IActionResult> AddInputChannel(InputChannelAddRequest input)
{
if (input?.ChannelType == ChannelType.Unknown)
{
return(BadRequest(new ApiValidationError(ErrorKeys.UnknownInputChannelType)));
}
Logger.LogDebug($"InputChannelController - AddInputChannel method called with this input: {input}");
var channel = Mapping.AutoMapper.Mapper.Map <InputChannel>(input);
await _inputChannelDa.AddInputChannelAsync(channel);
return(Ok(ApiValidatedResult <InputChannelAddResponse> .Ok(
Mapping.AutoMapper.Mapper.Map <InputChannelAddResponse>(channel))));
}
public async Task <IActionResult> AddTenant(AddTenantRequest request)
{
Logger.LogDebug(
$"{nameof(TenantController)} - {nameof(AddTenant)} method called with this input: {request}");
if (string.IsNullOrWhiteSpace(request.Identifier) || string.IsNullOrWhiteSpace(request.Name))
{
return(BadRequest(new { Message = ErrorKeys.ParameterNull }));
}
var input = Mapping.AutoMapper.Mapper.Map <Tenant>(request);
var result = await _tenantLogic.AddTenant(input);
if (result?.Error != null)
{
return(BadRequest(new { Message = result.Error }));
}
return(Ok(ApiValidatedResult <AddTenantResponse> .Ok(
Mapping.AutoMapper.Mapper.Map <AddTenantResponse>(input))));
}
