public async Task STATUS_Async()
{
try
{
ApiStatusResponse status = await new ApiStatus().PerformRequestAsync();
if (status.IsSuccess)
{
await ReplyAsync($"```Minecraft.net: {status.Minecraft}\r"
+ $"Mojang Accounts: {status.MojangAccounts}\r"
+ $"Mojang API: {status.MojangApi}\r"
+ $"Mojang Auth Servers: {status.MojangAutenticationServers}\r"
+ $"Mojang Sessions: {status.MojangSessionsServer}```");
}
else
{
await ReplyAsync(status.Error.Exception == null?status.Error.ErrorMessage : status.Error.Exception.Message);
}
}
catch (Exception ex)
{
await ReplyAsync("Mojang API service is offline! Try again later.");
Console.WriteLine(ex);
}
}
/// <summary>
/// Processamento do evento de pedido de get do tipo Get_ALL
/// </summary>
/// <returns>O resultado do processamento do evento</returns>
public HttpResponseMessage OnDoGetAll()
{
HttpResponseMessage response = null;
if (DoGetAll != null)
{
response = DoGetAll();
}
else
{
// retorna erro
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "000",
Detail = "Operação indisponível.",
Title = "Operação indisponível.",
Type = "error"
};
response = Controller.Request.CreateResponse <ApiStatusResponse>(HttpStatusCode.BadRequest, errorResponse);
}
return(response);
}
/// <summary>
/// Processamento do evento de pedido de querystring
/// </summary>
/// <returns>O resultado do processamento do evento</returns>
public HttpResponseMessage OnDoGetByQueryString()
{
HttpResponseMessage response = null;
if (DoGetByQueryString != null)
{
if ((MatchedFields != null) || (MatchedCommands != null))
{
response = DoGetByQueryString();
}
}
else
{
// retorna erro
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "000",
Detail = "Operação indisponível.",
Title = "Operação indisponível.",
Type = "error"
};
response = Controller.Request.CreateResponse <ApiStatusResponse>(HttpStatusCode.BadRequest, errorResponse);
}
return(response);
}
/// <summary>
/// Gere as excepções dentro dos controllers;
/// </summary>
/// <param name="ex"></param>
protected HttpResponseMessage ExceptionHandler(Exception ex)
{
ApiStatusResponse error = new ApiStatusResponse
{
Code = "500",
Title = "Internal Error",
Detail = ex.Message,
Type = "error"
};
return Request.CreateResponse<ApiStatusResponse>(HttpStatusCode.InternalServerError, error);
}
/// <summary>
/// Tratamento de erros por default
/// </summary>
/// <param name="request">Pedido HTTP</param>
/// <param name="ex">Erro a tratar</param>
/// <returns>HTTP Response: erro e mensagem</returns>
public HttpResponseMessage DefaultControllerException(HttpRequestMessage request, Exception ex)
{
ApiStatusResponse error = new ApiStatusResponse
{
Code = "500",
Title = "Internal Error",
Detail = ex.Message,
Type = "error"
};
return(request.CreateResponse <ApiStatusResponse>(HttpStatusCode.InternalServerError, error));
}
/// <summary>
/// Resposta standard para pedidos com recurso não encontrado
/// </summary>
/// <returns>HTTP Response: Resource Not Found</returns>
public HttpResponseMessage ResourceNotFound()
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "001",
Detail = "Recursos não encontrados",
Title = "Recursos não encontrados",
Type = "error"
};
return(Controller.Request.CreateResponse <ApiStatusResponse>(HttpStatusCode.NotFound, errorResponse));
}
public virtual HttpResponseMessage DoDelete(int id)
{
ApiStatusResponse errorResponse;
errorResponse = new ApiStatusResponse()
{
Code = "000",
Detail = "Operação indisponível.",
Title = "Operação indisponível.",
Type = "error"
};
return Request.CreateResponse<ApiStatusResponse>(HttpStatusCode.BadRequest, errorResponse);
}
protected override HttpResponseMessage DoPut(int Id, T item)
{
HttpResponseMessage response = new HttpResponseMessage();
// descobrir campo chave e saber valor
// se o valor do parametro nao for igual ao do campo chave
// é erro, logo nem avança
if (GetKeyValueOf(item) != Id)
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "101",
Detail = "Está a tentar executar a actulização de um objecto, mas tem incomsistência entre a chave do objecto e o ID do Uri",
Title = "Uri Inválido",
Type = "error"
};
response = Request.CreateResponse(HttpStatusCode.BadRequest, errorResponse);
}
else
{
var itemIns = tblData.Update(item);
if (itemIns == null)
{
// não update, mas não deu erro... portanto elemento não existe
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "102",
Detail = "Está a tentar executar a actulização de um objecto, mas o objecto não existe",
Title = "Operação Inválida",
Type = "error"
};
response = Request.CreateResponse(HttpStatusCode.NotFound, errorResponse);
}
else
{
ApiDataResponse res = new ApiDataResponse();
res.data = item;
res.recordsaffected = 1;
response = Request.CreateResponse <ApiDataResponse>(HttpStatusCode.OK, res);
string uri = Url.Link("DefaultApi", new { id = Id });
response.Headers.Location = new Uri(uri);
}
}
return(response);
}
public override HttpResponseMessage Put([FromUri] int id, [FromBody] T item)
{
ApiStatusResponse errorResponse;
errorResponse = new ApiStatusResponse()
{
Code = "000",
Detail = "Operação indisponível.",
Title = "Operação indisponível.",
Type = "error"
};
return(Request.CreateResponse <ApiStatusResponse>(HttpStatusCode.BadRequest, errorResponse));
}
/// <summary>
/// Get Generico
/// Trata o GetAll e Get com QueryString
/// </summary>
/// <returns></returns>
public virtual HttpResponseMessage Get()
{
HttpResponseMessage response = null;
if (QueryStringPairs != null)
{
QueryStringPairs = null;
}
QueryStringPairs = Request.GetQueryNameValuePairs();
// se não têm querystring
if (QueryStringPairs.Count() <= 0)
{
// standard get all
try
{
response = DoGetAll();
}
catch (Exception ex)
{
response = ExceptionHandler(ex);
}
}
else
{
// tem querystring mas é inválida
if (QueryStringPairs == null)
{
// retorna erro
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = "Está a tentar executar uma querystring inválida",
Title = "Querystring inválida",
Type = "error"
};
return Request.CreateResponse<ApiStatusResponse>(HttpStatusCode.BadRequest, errorResponse);
}
// trata a query string
try
{
// a querystring é válida
// definir campos e comandos válidos
DefineFieldsAllowedForQuery();
DefineCommandsAllowedForQuery();
// agora vamos ver se temos campos na querystring
// exemplo: cmoeda (os campos não têm prefixo. só os comandos)
var QueryFields = from itemCommand in QueryStringPairs
where !itemCommand.Key.ToLowerInvariant().StartsWith("@")
select itemCommand;
if ((QueryFields != null) && (QueryFields.Count<KeyValuePair<string, string>>() == 0))
{
QueryFields = null;
}
// limpar
if (MatchedFields != null)
{
MatchedFields = null;
}
// temos campos, vamos ver se são da lista de campos
// válidos
if (!QueryFields.IsNullOrEmpty())
{
MatchedFields = (from itemField in QueryFields
where FieldsAllowedForQuery.Contains(itemField.Key.ToLowerInvariant())
select itemField).ToDictionary(kv => kv.Key, kv => kv.Value,
StringComparer.OrdinalIgnoreCase);
}
if ((MatchedFields != null) && (MatchedFields.Count<KeyValuePair<string, string>>() == 0))
{
MatchedFields = null;
}
// agora vamos ver se temos comandos na querystring
// os comandos são identificados pelo perfixo @
// exemplo: @page
var QueryCommands = from itemCommand in QueryStringPairs
where itemCommand.Key.ToLowerInvariant().StartsWith("@")
select itemCommand;
if ((QueryCommands != null) && (QueryCommands.Count<KeyValuePair<string, string>>() == 0))
{
QueryCommands = null;
}
// limpar
if (MatchedCommands != null)
{
MatchedCommands = null;
}
// temos comandos, vamos ver se pertencem à lista de comandos válidos
if (!QueryCommands.IsNullOrEmpty())
{
MatchedCommands = (from itemCommand in QueryCommands
where CommandsAllowedForQuery.Contains(itemCommand.Key.ToLowerInvariant())
select itemCommand).ToDictionary(kv => kv.Key, kv => kv.Value,
StringComparer.OrdinalIgnoreCase); ;
}
if ((MatchedCommands != null) && (MatchedCommands.Count<KeyValuePair<string, string>>() == 0))
{
MatchedCommands = null;
}
// se não tem campos e comandos
var hasValidFields = !MatchedFields.IsNullOrEmpty();
var hasValidCommands = !MatchedCommands.IsNullOrEmpty();
if (!hasValidFields && !hasValidCommands)
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = "Está a tentar executar uma querystring inválida. Tem de indicar campos e/ou comandos válidos.",
Title = "Querystring inválida",
Type = "error"
};
return Request.CreateResponse<ApiStatusResponse>(HttpStatusCode.BadRequest, errorResponse);
}
// tem comandos na qyerystring?
if (!QueryCommands.IsNullOrEmpty())
{
// mas não são válidos
if (!hasValidCommands)
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = "Está a tentar executar uma querystring inválida, utilizando comandos não suportados",
Title = "Querystring inválida",
Type = "error"
};
return Request.CreateResponse<ApiStatusResponse>(HttpStatusCode.BadRequest, errorResponse);
}
}
// tem campos na query string?
if (!QueryFields.IsNullOrEmpty())
{
// são válidos?
if (!hasValidFields)
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = "Está a tentar executar uma querystring inválida, utilizando campos não suportados",
Title = "Querystring inválida",
Type = "error"
};
return Request.CreateResponse<ApiStatusResponse>(HttpStatusCode.BadRequest, errorResponse);
}
}
// process querystring, temos comandos ou campos
response = DoGetByQueryString();
}
catch (Exception ex)
{
response = ExceptionHandler(ex);
}
}
return response;
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Id"></param>
/// <param name="item"></param>
/// <param name="activeTransaction"></param>
/// <returns></returns>
public HttpResponseMessage GenericPut <T>(int Id, T item, IDbTransaction activeTransaction = null) where T : class
{
HttpResponseMessage response;
// descobrir campo chave e saber valor
// se o valor do parametro nao for igual ao do campo chave
// é erro, logo nem avança
if (DatabaseHelpers.GetKeyValueOf(item) != Id)
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "101",
Detail = "Está a tentar executar a actulização de um objecto, mas tem incomsistência entre a chave do objecto e o ID do Uri",
Title = "Uri Inválido",
Type = "error"
};
response = Controller.Request.CreateResponse(HttpStatusCode.BadRequest, errorResponse);
}
else
{
DbTable <T> tblData = new DbTable <T>(DBContext, UserID);
try
{
var itemIns = tblData.Update(item, activeTransaction);
tblData = null;
if (itemIns == null)
{
// não update, mas não deu erro... portanto elemento não existe
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "102",
Detail = "Está a tentar executar a actulização de um objecto, mas o objecto não existe",
Title = "Operação Inválida",
Type = "error"
};
response = Controller.Request.CreateResponse(HttpStatusCode.NotFound, errorResponse);
}
else
{
ApiDataResponse res = new ApiDataResponse();
res.data = item;
res.recordsaffected = 1;
response = Controller.Request.CreateResponse <ApiDataResponse>(HttpStatusCode.OK, res);
// Erro no parametro request
//UrlHelper url = new UrlHelper();
//string uri = url.Link("DefaultApi", new { id = Id });
//response.Headers.Location = new Uri(uri);
}
}
catch (Exception ex)
{
tblData = null;
response = DefaultControllerException(Controller.Request, ex);
}
tblData = null;
}
return(response);
}
public async Task <IActionResult> Post([FromBody] TeamViewModel teamViewModel)
{
IActionResult result = null;
var managerId = Convert.ToInt32(User.FindFirstValue(ClaimTypes.NameIdentifier));
Team team = null;
bool hasError = false;
PromotionalCode promoCode = null;
await ValidateTeamName(teamViewModel);
await ValidatePlayerData(teamViewModel);
if (!string.IsNullOrWhiteSpace(teamViewModel.PromotionalCode))
{
promoCode = await ValidatePromoCode(teamViewModel);
}
if (ModelState.IsValid)
{
// perform update of team/player data
if (teamViewModel.Id.HasValue && teamViewModel.Id.Value > 0)
{
team = TeamRepository.All.SingleOrDefault(t => t.ManagerId == managerId && t.Id == teamViewModel.Id.Value);
if (team == null)
{
// log exception, notify user they are trying to edit a team they are not a manager of
var error = new ApiStatusResponse
{
Messages = new List <string>(new string[] { "You are trying to edit a team that you do not manage." }),
StatusCode = Microsoft.AspNetCore.Http.StatusCodes.Status403Forbidden
};
Response.StatusCode = error.StatusCode;
result = new ObjectResult(error);
hasError = true;
}
else
{
Mapper.Map(teamViewModel, team);
await UpdateParticipants(teamViewModel, managerId);
}
}
// add new team/players
else
{
// map team information
team = Mapper.Map <Team>(teamViewModel);
team.ManagerId = managerId;
// map any player information
foreach (ParticipantViewModel participant in teamViewModel.Players)
{
if (team.Members == null)
{
team.Members = new List <Participant>();
}
team.Members.Add(Mapper.Map <Participant>(participant));
}
}
if (!hasError)
{
if (promoCode != null)
{
team.PromotionalCodeId = promoCode.Id;
}
TeamRepository.InsertOrUpdate(team);
try
{
await TeamRepository.SaveAsync();
var teamId = team.Id;
team = await TeamRepository.All.Include(t => t.Division).Include(t => t.Gender).Include(t => t.CompetitionLevel).Include(t => t.Members).Where(t => t.ManagerId == managerId && t.Id == teamId).SingleOrDefaultAsync();
if (team.Members == null)
{
team.Members = new List <Participant>();
}
teamViewModel = Mapper.Map <TeamViewModel>(team);
teamViewModel.Validate(team);
result = Json(teamViewModel);
}
catch (Exception e)
{
// need to log exception and then let the user know that their team could not be saved.
var error = new ApiStatusResponse
{
Messages = new List <string>(new string[] { e.Message }),
StatusCode = Microsoft.AspNetCore.Http.StatusCodes.Status400BadRequest
};
Response.StatusCode = error.StatusCode;
result = new ObjectResult(error);
}
}
}
else
{
// need to add all model state errors
var error = new ApiStatusResponse
{
Messages = new List <string>(),
StatusCode = Microsoft.AspNetCore.Http.StatusCodes.Status422UnprocessableEntity
};
foreach (var key in ModelState.Keys)
{
foreach (var modelStateError in ModelState[key].Errors)
{
var player = "";
switch (key)
{
case string k when(k.IndexOf("players[0]", StringComparison.CurrentCultureIgnoreCase) > -1):
player = "Captain";
break;
case string k when(k.IndexOf("players[1]", StringComparison.CurrentCultureIgnoreCase) > -1):
player = "Player #2";
break;
case string k when(k.IndexOf("players[2]", StringComparison.CurrentCultureIgnoreCase) > -1):
player = "Player #3";
break;
case string k when(k.IndexOf("players[3]", StringComparison.CurrentCultureIgnoreCase) > -1):
player = "Player #4";
break;
}
error.Messages.Add($"{player} - {modelStateError.ErrorMessage}");
}
}
Response.StatusCode = error.StatusCode;
result = new ObjectResult(error);
}
return(result);
}
/// <summary>
/// Validação e processamento da querystring
/// Neste método está toda a inteligencia necessária para separar e preparar
/// a querystring para execução do controller
/// </summary>
/// <returns> Erros a retornar pela API</returns>
public ApiStatusResponse ValidateQryString()
{
QueryStringPairs = null;
QueryStringPairs = Controller.Request.GetQueryNameValuePairs();
// tem querystring mas é inválida
if (QueryStringPairs == null)
{
// retorna erro
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = "Está a tentar executar uma querystring inválida",
Title = "Querystring inválida",
Type = "error"
};
return(errorResponse);
}
// se não têm querystring
if (QueryStringPairs.Count() <= 0)
{
// não há nada a validar
return(null);
}
// agora vamos ver se temos campos na querystring
// exemplo: cmoeda (os campos não têm prefixo. só os comandos)
var QueryFields = from itemCommand in QueryStringPairs
where !itemCommand.Key.ToLowerInvariant().StartsWith("@")
select itemCommand;
if ((QueryFields != null) && (QueryFields.Count <KeyValuePair <string, string> >() == 0))
{
QueryFields = null;
}
// limpar
MatchedFields = null;
// temos campos, vamos ver se são da lista de campos
// válidos
if (!QueryFields.IsNullOrEmpty())
{
var tempMatchedFields = (from itemField in QueryFields
where FieldsAllowedForQuery.Find(itemField.Key.ToLowerInvariant()) != null
select itemField).ToDictionary(kv => kv.Key, kv => kv.Value,
StringComparer.OrdinalIgnoreCase);
MatchedFields = new Dictionary <string, AutorizedField>();
foreach (var match in tempMatchedFields)
{
var foundField = FieldsAllowedForQuery.Find(match.Key.ToLowerInvariant());
if ((match.Value.ToString().IndexOf('§') >= 0))
{
foundField.Value = match.Value.Replace('§', '%');
}
else
{
foundField.Value = match.Value;
}
MatchedFields.Add(match.Key, foundField);
}
}
if ((MatchedFields != null) && (MatchedFields.Count <KeyValuePair <string, AutorizedField> >() == 0))
{
MatchedFields = null;
}
// agora vamos ver se temos comandos na querystring
// os comandos são identificados pelo perfixo @
// exemplo: @page
var QueryCommands = from itemCommand in QueryStringPairs
where itemCommand.Key.ToLowerInvariant().StartsWith("@")
select itemCommand;
if ((QueryCommands != null) && (QueryCommands.Count <KeyValuePair <string, string> >() == 0))
{
QueryCommands = null;
}
// limpar
MatchedCommands = null;
// temos comandos, vamos ver se pertencem à lista de comandos válidos
if (!QueryCommands.IsNullOrEmpty())
{
MatchedCommands = (from itemCommand in QueryCommands
where CommandsAllowedForQuery.Contains(itemCommand.Key.ToLowerInvariant())
select itemCommand).ToDictionary(kv => kv.Key, kv => kv.Value,
StringComparer.OrdinalIgnoreCase);
}
if ((MatchedCommands != null) && (MatchedCommands.Count <KeyValuePair <string, string> >() == 0))
{
MatchedCommands = null;
}
// se não tem campos e comandos
var hasValidFields = !MatchedFields.IsNullOrEmpty();
var hasValidCommands = !MatchedCommands.IsNullOrEmpty();
if (!hasValidFields && !hasValidCommands)
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = "Está a tentar executar uma querystring inválida. Tem de indicar campos e/ou comandos válidos.",
Title = "Querystring inválida",
Type = "error"
};
return(errorResponse);
}
// tem comandos na qyerystring?
if (!QueryCommands.IsNullOrEmpty())
{
// mas não são válidos ou tem a mais
if (!hasValidCommands | (MatchedCommands.Count() != QueryCommands.Count()))
{
MatchedCommands.Clear();
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = "Está a tentar executar uma querystring inválida, utilizando comandos não suportados",
Title = "Querystring inválida",
Type = "error"
};
return(errorResponse);
}
else
{
// comandos válidos encontrados, vamos validar os comandos standard os restantes não são validados
// @limit
// @page
// @order
foreach (var item in MatchedCommands)
{
string command = item.Key.ToLowerInvariant();
switch (command)
{
case "@order":
{
if ((FieldsAllowedForOrder == null) || (FieldsAllowedForOrder.Count <= 0))
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = "Está a tentar executar uma querystring inválida, utilizando campos para ordenação não suportados",
Title = "Querystring inválida",
Type = "error"
};
return(errorResponse);
}
OrderByFields = null;
OrderByFields = new Dictionary <string, OrderByField>();
string[] fields = item.Value.Split(',');
foreach (string s in fields)
{
OrderByField field = new OrderByField()
{
FieldName = s
};
OrderByFields.Add(field.FieldName, field);
}
if (!OrderByFields.IsNullOrEmpty())
{
MatchedOrderFields = (from itemCommand in OrderByFields
where FieldsAllowedForOrder.Find(itemCommand.Key.ToLowerInvariant()) != null
select itemCommand).ToDictionary(kv => kv.Key, kv => kv.Value,
StringComparer.OrdinalIgnoreCase);
}
if ((MatchedOrderFields != null) && (MatchedOrderFields.Count <KeyValuePair <string, OrderByField> >() == 0))
{
MatchedOrderFields = null;
}
var hasValidOrderFields = !MatchedOrderFields.IsNullOrEmpty();
if (!hasValidOrderFields || (MatchedOrderFields.Count() != OrderByFields.Count()))
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = "Está a tentar executar uma querystring inválida, utilizando campos para ordenação não suportados",
Title = "Querystring inválida",
Type = "error"
};
return(errorResponse);
}
break;
}
// comandos de paginação
case "@limit":
case "@page":
{
HasPagingCommand = true;
if (command == "@limit")
{
try
{
PageSize = Convert.ToInt32(item.Value);
if (PageSize <= 0)
{
throw new ArgumentException();
}
}
catch (Exception)
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = "Está a tentar executar uma querystring inválida, utilizando um valor invalido para o comando @limit",
Title = "Querystring inválida",
Type = "error"
};
return(errorResponse);
}
}
if (command == "@page")
{
try
{
PageNumber = Convert.ToInt32(item.Value);
if (PageNumber <= 0)
{
throw new ArgumentException();
}
}
catch (Exception)
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = "Está a tentar executar uma querystring inválida, utilizando um valor invalido para o comando @page",
Title = "Querystring inválida",
Type = "error"
};
return(errorResponse);
}
}
break;
}
default:
{
if (!item.Value.IsNaturalNumber())
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = $"Está a tentar executar uma querystring inválida, com valores dos comandos @limit, @offset e @pagenumber invlálidos. Valor: {item.Value}",
Title = "Querystring inválida",
Type = "error"
};
return(errorResponse);
}
break;
}
}
}
}
}
// tem campos os na query string?
if (!QueryFields.IsNullOrEmpty())
{
// erro se não têm campos válidos ou se além de válidos tem outros não reconhecidos
if (!hasValidFields || (MatchedFields.Count() != QueryFields.Count()))
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = "Está a tentar executar uma querystring inválida, utilizando campos não suportados",
Title = "Querystring inválida",
Type = "error"
};
return(errorResponse);
}
// temos campos, mas só vamos permitir MaxNumberFieldsOnQueryString
// se este for maior que 0
if ((MaxNumberFieldsOnQueryString > 0) && (MatchedFieldsCount > MaxNumberFieldsOnQueryString))
{
ApiStatusResponse errorResponse = new ApiStatusResponse()
{
Code = "100",
Detail = $"Não é possivel executar porque a querystring. Só pode filtrar por {MaxNumberFieldsOnQueryString} campo(s) de cada vez.",
Title = "Querystring inválida",
Type = "error"
};
return(errorResponse);
}
}
return(null);
}
