public IActionResult GetAuthorForArticles(Guid authorId)
{
ApiResponseMessage <AuthorDTO> apiResponseMessage = new ApiResponseMessage <AuthorDTO>()
{
Succeed = false, Message = "", Data = null
};
if (authorId == Guid.Empty)
{
return(BadRequest());
}
if (!_authorRepository.AuthorExists(authorId))
{
return(NoContent());
}
var authorForArticlesModel = _mapper.Map <AuthorDTO>(_authorRepository.GetAuthorForArticles(authorId));
if (authorForArticlesModel != null)
{
apiResponseMessage.Succeed = true;
apiResponseMessage.Message = $"Islem basarili.";
apiResponseMessage.Data = authorForArticlesModel;
}
return(Ok(apiResponseMessage));
}
//para funcionar o binding de um xml para um array ou list a classe correspondente ao parâmetro
//deve ser decorada com a propriedade "[DataContract]" e as propriedades da classe que precisam
//ser serializadas devem ser decoradas com a propriedade "[DataMember]"
//Se na origem da requisição o dado for um json isto não é necessário.
//Ver explicação em: http://www.asp.net/web-api/overview/formats-and-model-binding/json-and-xml-serialization
public HttpResponseMessage PostMultiplo([FromBody] ListaUsuario usuarios)
{
ApiResponseMessage retornoPortal;
try
{
var usuariosComNome = usuarios.Where(x => !string.IsNullOrEmpty(x.Nome)).ToList();
int quantidadeDeUsuariosSemNome = usuarios.Count - usuariosComNome.Count;
_cadastroUsuario.AtualizarUsuarios(usuariosComNome);
retornoPortal = new ApiResponseMessage()
{
Retorno = new Retorno()
{
Codigo = "200", Texto = usuariosComNome.Count + " usuários atualizados." +
(quantidadeDeUsuariosSemNome > 0 ? quantidadeDeUsuariosSemNome + " usuários não atualizados: " +
string.Join(", ", usuarios.Where(x => string.IsNullOrEmpty(x.Nome)).Select(u => u.Login)) + "." : "")
}
};
return(Request.CreateResponse(HttpStatusCode.OK, retornoPortal));
}
catch (Exception ex)
{
retornoPortal = ExceptionUtil.GeraExecaoDeErroParaWebApi(ex);
return(Request.CreateResponse(HttpStatusCode.OK, retornoPortal));
}
}
public IActionResult GetAuthor(Guid authorId)
{
ApiResponseMessage <AuthorDTO> apiResponseMessage = new ApiResponseMessage <AuthorDTO>()
{
Succeed = false, Message = "", Data = null
};
if (authorId == Guid.Empty)
{
return(BadRequest("Mesaj yaz"));
}
var authorModel = _mapper.Map <AuthorDTO>(_authorRepository.GetAuthor(authorId));
if (authorModel == null)
{
//return NoContent("Mesaj yaz");
}
apiResponseMessage.Succeed = true;
apiResponseMessage.Message = $"Islem basarili. GetAuthor";
apiResponseMessage.Data = authorModel;
return(Ok(apiResponseMessage));
}
public async Task Is_HttpContent_Read_As_ApiResponseMessage_Async()
{
// Arrange
HttpContent httpContent = new StringContent(
@"{ ""Code"" : 200,
""Message"": {""Header"" : ""Test header"", ""Body"" : ""Test body""},
""Info"" : ""Extra info""
}");
var expectedApiResponseMessage = new ApiResponseMessage <ExampleMessageType>()
{
Code = (HttpStatusCode)200,
Message = new ExampleMessageType {
Header = "Test header", Body = "Test body"
},
Info = "Extra info"
};
// Act
var actualApiResponseMessage = await httpContent.ReadAsApiResponseMessageAsync <ExampleMessageType>();
// Assert
Assert.AreEqual(expectedApiResponseMessage.Code, actualApiResponseMessage.Code);
Assert.AreEqual(expectedApiResponseMessage.Message.Header, actualApiResponseMessage.Message.Header);
Assert.AreEqual(expectedApiResponseMessage.Message.Body, actualApiResponseMessage.Message.Body);
Assert.AreEqual(expectedApiResponseMessage.Info, actualApiResponseMessage.Info);
}
public BasicApiResponse(bool successful, params ErrorMessage[] messages)
{
ApiMessage = new ApiResponseMessage()
{
Successful = successful, Errors = messages
};
}
/// <summary>
/// 接口统一的返回消息
/// </summary>
/// <param name="result">返回内容</param>
/// <returns></returns>
protected HttpResponseMessage ApiResponse(ApiResponseMessage result)
{
HttpResponseMessage response = new HttpResponseMessage
{
Content = new ObjectContent <ApiResponseMessage>(result, Configuration.Formatters.JsonFormatter),
};
return(response);
}
//para funcionar o binding de um xml para um array ou list a classe correspondente ao parâmetro
//deve ser decorada com a propriedade "[DataContract]" e as propriedades da classe que precisam
//ser serializadas devem ser decoradas com a propriedade "[DataMember]"
//Se na origem da requisição o dado for um json isto não é necessário.
//Ver explicação em: http://www.asp.net/web-api/overview/formats-and-model-binding/json-and-xml-serialization
public HttpResponseMessage PostMultiplo([FromBody] ListaProdutos produtos)
{
ApiResponseMessage retornoPortal;
try
{
_cadastroProduto.AtualizarProdutos(produtos);
retornoPortal = new ApiResponseMessage()
{
Retorno = new Retorno()
{
Codigo = "200", Texto = produtos.Count + " produtos atualizados"
}
//retorno = new retorno() { retCodigo = "200", retTexto = produtos.Produtos.Count + " produtos atualizados" }
};
return(Request.CreateResponse(HttpStatusCode.OK, retornoPortal));
}
catch (Exception ex)
{
string detalhes = "";
if (produtos == null)
{
detalhes = "A lista de produtos esta nula";
}
else if (produtos.Count == 0)
{
detalhes = "A lista de produtos esta vazia";
}
else
{
for (int i = 0; i < produtos.Count; i++)
{
detalhes += "Produto " + i + ": Codigo: " + (string.IsNullOrEmpty(produtos[i].Codigo)
? "nulo" : produtos[i].Codigo)
+ " - Tipo: " + (string.IsNullOrEmpty(produtos[i].Tipo)
? "nulo" : produtos[i].Tipo
+ " - Descricao: " + (string.IsNullOrEmpty(produtos[i].Descricao)
? "nulo": produtos[i].Descricao));
}
}
retornoPortal = new ApiResponseMessage()
{
Retorno = new Retorno()
{
Codigo = "500", Texto = "Erro interno. Mensagem: " + ex.Message
+ (ex.InnerException != null ? " - Excecao Interna: " + ex.InnerException.Message : "")
+ " - Pilha de Execucao: " + ex.StackTrace + " - Detalhes: " + detalhes
}
};
return(Request.CreateResponse(HttpStatusCode.OK, retornoPortal));
}
}
private Task <string> ResponseData(bool isSuccess, dynamic dataResponse, ApiResponseMessage message)
{
ResponseViewModel response = new ResponseViewModel()
{
IsSuccess = isSuccess,
Message = message.Message,
Data = dataResponse
};
return(Task.FromResult(response.ToJsonCamel()));
}
//public ComunicacaoFechamentoProcessoCotacaoFrete(CredencialSap credencialSap)
//{
// _comunicacaoSap = new ComunicacaoSap<ListaProcessoDeCotacaoDeFreteFechamento>(credencialSap);
//}
public ApiResponseMessage EfetuarComunicacao(ProcessoDeCotacao processo)
{
ProcessoDeCotacaoItem item = processo.Itens.First();
if (item.Produto.NaoEstocavel)
{
//Cotações de frete para empresas do grupo que não utilizam o SAP deverão ser realizadas com material NLAG
//(Material não estocável). Para este tipo de material a cotação não deverá ser enviada para o SAP;
return(new ApiResponseMessage
{
Retorno = new Retorno
{
Codigo = "200",
Texto = "S"
}
});
}
var mensagemParaEnviar = new ListaProcessoDeCotacaoDeFreteFechamento();
var processoAuxiliar = (ProcessoDeCotacaoDeFrete)processo.CastEntity();
foreach (var fornecedorParticipante in processoAuxiliar.FornecedoresParticipantes)
{
if (fornecedorParticipante.Cotacao != null && fornecedorParticipante.Cotacao.Itens.First().Selecionada)
{
CotacaoItem itemDaCotacao = fornecedorParticipante.Cotacao.Itens.First();
mensagemParaEnviar.Add(new ProcessoDeCotacaoDeFreteFechamentoComunicacaoSapVm
{
CodigoTransportadora = fornecedorParticipante.Fornecedor.Codigo,
//CodigoMaterial = processoAuxiliar.Produto.Codigo,
CodigoMaterial = item.Produto.Codigo,
//CodigoUnidadeMedida = processoAuxiliar.UnidadeDeMedida.CodigoInterno,
CodigoUnidadeMedida = item.UnidadeDeMedida.CodigoInterno,
CodigoItinerario = processoAuxiliar.Itinerario.Codigo,
DataDeValidadeInicial = processoAuxiliar.DataDeValidadeInicial.ToString("yyyyMMdd"),
DataDeValidaFinal = processoAuxiliar.DataDeValidadeFinal.ToString("yyyyMMdd"),
NumeroDoContrato = processoAuxiliar.NumeroDoContrato ?? "",
Valor = itemDaCotacao.ValorComImpostos
});
}
}
ApiResponseMessage apiResponseMessage =
_comunicacaoSap.EnviarMensagem(
"/HttpAdapter/HttpMessageServlet?senderParty=PORTAL&senderService=HTTP&interfaceNamespace=http://portal.bsbios.com.br/&interface=si_cotacaoFreteFechamento_portal&qos=be"
, mensagemParaEnviar);
if (apiResponseMessage.Retorno.Codigo == "E")
{
throw new ComunicacaoSapException("json", "Ocorreu um erro ao comunicar o fechamento do Processo de Cotação de Frete para o SAP. Detalhes: " + apiResponseMessage.Retorno.Texto);
}
return(apiResponseMessage);
}
private /*async*/ void ExecutaChamadaAssincrona()
{
//var configuration = new HttpConfiguration();
//configuration.Formatters.XmlFormatter.UseXmlSerializer = true;
var clientHandler = new HttpClientHandler();
clientHandler.Credentials = new NetworkCredential("fusion_lucas", "fusion123");
var httpClient = new HttpClient(clientHandler);
var mensagemParaEnviar = new ApiResponseMessage()
{
Retorno = new Retorno()
{
Codigo = "100",
Texto = "blablabla"
}
};
var response = httpClient.PostAsXmlAsync("http://sap-pid.bsbios.com:50000/HttpAdapter/HttpMessageServlet?senderParty=PORTAL&senderService=HTTP&interfaceNamespace=http://portal.bsbios.com.br/&interface=si_envioStatus_portal&qos=be"
, mensagemParaEnviar);
Assert.IsTrue(response.Result.IsSuccessStatusCode);
//var retorno = response.Result.Content.ReadAsAsync<ApiResponseMessage>();
//var retorno = response.Result.Content.ReadAsStringAsync();
Stream content = response.Result.Content.ReadAsStreamAsync().Result;
var serializer = new XmlSerializer(typeof(ApiResponseMessage) /*,"http://schemas.datacontract.org/2004/07/BsBios.Portal.ViewModel"*/);
var responseMessage = (ApiResponseMessage)serializer.Deserialize(content);
//var responseMessage = retorno.Result;
Assert.IsNotNull(responseMessage);
Assert.AreEqual("24", responseMessage.Retorno.Codigo);
//*await*/ httpClient.PostAsXmlAsync("http://sap-pid.bsbios.com:50000/HttpAdapter/HttpMessageServlet?senderParty=PORTAL&senderService=HTTP&interfaceNamespace=http://portal.bsbios.com.br/&interface=si_envioStatus_portal&qos=be"
// , mensagemParaEnviar).ContinueWith(
// requestTask =>
// {
// Console.WriteLine("requestTask");
// HttpResponseMessage response = requestTask.Result;
// response.EnsureSuccessStatusCode();
// response.Content.ReadAsAsync<ApiResponseMessage>().ContinueWith(
// readTask =>
// {
// Console.WriteLine("readTask");
// Assert.AreEqual("200", readTask.Result.Retorno.Codigo);
// });
// });
Console.WriteLine("Fim do Teste");
}
public ApiResponseMessage EfetuarComunicacao(ProcessoDeCotacao processo)
{
//seleciona os participantes que preencheram a cotação (cotacaoMaterial != null)
//e que ainda não possuem número da cotação. O esperado é que nenhuma das cotações possuem NumeroDaCotacao.
//Isto acontecerá apenas se ocorrer erro na comunicação com o sap em para uns dos fornecedores do processo
//e antes deste fornecedor, a comunicação tenha sido realizada com sucesso para outro fornecedor.
//Neste cenário o fornecedor anterior já tem um número de cotação e não deve ser mais enviado para o SAP,
//pois isto faria com que fosse criado duas cotações para o mesmo fornecedor e item de requisição, o que é errado.
var participantesSemCotacaoNoSap = (from fp in processo.FornecedoresParticipantes
let cotacaoMaterial = (CotacaoMaterial)fp.Cotacao.CastEntity()
where string.IsNullOrEmpty(fp.NumeroDaCotacao)
select fp);
foreach (var fornecedorParticipante in participantesSemCotacaoNoSap)
{
var itens = new ListaProcessoDeCotacaoDeMaterialAberturaItemVm();
itens.AddRange(from ProcessoDeCotacaoDeMaterialItem item in processo.Itens
select new ProcessoDeCotacaoDeMaterialAberturaItemVm
{
NumeroRequisicao = item.RequisicaoDeCompra.Numero,
NumeroItem = item.RequisicaoDeCompra.NumeroItem
});
var vm = new ProcessoDeCotacaoDeMaterialAberturaComunicacaoSapVm
{
IdProcessoCotacao = processo.Id,
CodigoFornecedor = fornecedorParticipante.Fornecedor.Codigo,
DataLimiteRetorno = processo.DataLimiteDeRetorno.Value.ToString("dd.MM.yyyy"),
Itens = itens
};
//comentado enquanto o serviço do SAP não é implementado
ApiResponseMessage resposta = _comunicacaoSap.EnviarMensagem("/HttpAdapter/HttpMessageServlet?senderParty=PORTAL&senderService=HTTP&interfaceNamespace=http://portal.bsbios.com.br/&interface=si_cadCotacaoAbertura_portal&qos=be", vm);
if (resposta.Retorno.Codigo.Equals("200") && !string.IsNullOrEmpty(resposta.Retorno.Texto))
{
fornecedorParticipante.AtualizarNumeroDaCotacao(resposta.Retorno.Texto);
}
else
{
throw new Exception("Ocorreu um erro ao enviar os dados do Processo de Cotação para o SAP.");
}
}
return(new ApiResponseMessage()
{
Retorno = new Retorno()
{
Codigo = "200", Texto = "OK"
}
});
}
/// <summary>
/// Tries to read <see cref="HttpContent"/> as an <see cref="ApiResponseMessage{TMessageType}"/>
/// with <see cref="ApiResponseMessage{TMessageType}.Message"/> set to <typeparam name="TExpectedMessageType"/>
/// as a synchronous operation
/// </summary>
/// <typeparam name="TExpectedMessageType"></typeparam>
/// <param name="content"></param>
/// <param name="apiResponseMessage"></param>
/// <param name="contractResolver">Which contract resolver to use for deserializing Json. Default is <see cref="CamelCasePropertyNamesContractResolver"/></param>
/// <returns><see cref="ApiResponseMessage{TMessageType}"/> with the <see cref="ApiResponseMessage{TMessageType}.Message"/>
/// property set to <typeparam name="TExpectedMessageType"/></returns>
public static bool TryReadAsApiResponseMessage <TExpectedMessageType>(
this HttpContent content,
out ApiResponseMessage <TExpectedMessageType> apiResponseMessage,
IContractResolver contractResolver)
{
var json = content.ReadAsStringAsync().Result;
var parsed = json.TryParse <ApiResponseMessage <TExpectedMessageType> >();
if (parsed == null)
{
apiResponseMessage = default(ApiResponseMessage <TExpectedMessageType>);
return(false);
}
apiResponseMessage = parsed;
return(true);
}
public ApiResponseMessage <List <ProductViewModel> > GetProductGroupDateTotalUsageAmount(string usageaccountid, int pageCnt, int pageRows)
{
Logger.Info("Start API GetProductGroupDateTotalUsageAmount List");
if (usageaccountid == null)
{
var resp = new ApiResponseMessage <List <ProductViewModel> >();
resp.StatusCode = HttpStatusCode.BadRequest;
resp.Message.Add("Request data is empty");
return(resp);
}
ApiResponseMessage <List <ProductViewModel> > response = new ApiResponseMessage <List <ProductViewModel> >();
response = ValuesHandler.GetProductGroupDateTotalUsageAmountById(usageaccountid, pageCnt, pageRows);
Logger.Info("End API GetProductGroupDateTotalUsageAmount List");
return(response);
}
public void ConsigoEnviarMensagemDeFechamentoDoProcessoDeCotacaoDeFreteUtilizandoServico()
{
ProcessoDeCotacaoDeFrete processo = DefaultObjects.ObtemProcessoDeCotacaoDeFreteComCadastrosExistentes();
var fornecedor = new Fornecedor("0000101815", "AIRGAS COM E TRANSP LTDA", "*****@*****.**", "", "Passo Fundo", "RS", true);
processo.AdicionarFornecedor(fornecedor);
processo.Abrir(DefaultObjects.ObtemUsuarioPadrao());
CotacaoFrete cotacaoFrete = processo.InformarCotacao(fornecedor.Codigo, 100, 110, "obs");
processo.SelecionarCotacao(cotacaoFrete.Id, 50);
var comunicacaoSap = ObjectFactory.GetInstance <IComunicacaoSap <ListaProcessoDeCotacaoDeFreteFechamento> >();
//var credencialSap = ObjectFactory.GetInstance<CredencialSap>();
var comunicaoFechamento = new ComunicacaoFechamentoProcessoCotacaoFrete(comunicacaoSap);
ApiResponseMessage mensagem = comunicaoFechamento.EfetuarComunicacao(processo);
Assert.AreEqual("S", mensagem.Retorno.Codigo);
}
public override void OnAuthorization(HttpActionContext actionContext)
{
// 匿名访问验证
var anonymousAction = actionContext.ActionDescriptor.GetCustomAttributes <AllowAnonymousAttribute>();
if (!anonymousAction.Any())
{
ApiResponseMessage result = null;
// token存在验证
var token = actionContext.ControllerContext.Request.Headers.FirstOrDefault(x => x.Key == "token").Value.FirstOrDefault();
if (string.IsNullOrEmpty(token))
{
result = new ApiResponseMessage(ResultStatus.UnAuthorize, "未登录");
}
else
{
token = SecurityHelper.DecryptDES(token, Common.ConstFiled.OpenIdEncryptKey);
//token合法验证
var sign = CacheHelper.GetCache(token);
if (sign == null)
{
var user = _repositoryFactory.IWeChatMember.Single(x => x.OpenId == token);
if (user == null)
{
result = new ApiResponseMessage(ResultStatus.UnAuthorize, "未注册用户");
}
else
{
CacheHelper.SetCache(token, user, TimeSpan.FromHours(5));
}
}
}
if (result != null)
{
var response = new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.Unauthorized
};
response.Content = new ObjectContent <ApiResponseMessage>(result,
actionContext.ActionDescriptor.Configuration.Formatters.JsonFormatter);
actionContext.Response = response;
return;
}
}
}
public IActionResult GetAuthors()
{
ApiResponseMessage <List <AuthorDTO> > apiResponseMessage = new ApiResponseMessage <List <AuthorDTO> >()
{
Succeed = false, Message = "", Data = null
};
var authorsModels = _mapper.Map <List <AuthorDTO> >(_authorRepository.GetAuthors());
if (authorsModels.Count > 0)
{
apiResponseMessage.Succeed = true;
apiResponseMessage.Message = $"Islem basarili.";
apiResponseMessage.Data = authorsModels;
}
return(Ok(apiResponseMessage));
}
public IActionResult Post([FromBody] OrderDTO order)
{
var returnMessage = new ApiResponseMessage();
try
{
var id = this._orderService.Save(order);
returnMessage.Success = true;
returnMessage.Message = "Order " + id + " created";
return(Ok(returnMessage));
}
catch (ProductNotSupportedException ex)
{
returnMessage.Success = false;
returnMessage.Message = ex.Message;
return(BadRequest(returnMessage));
}
}
public ApiResponseMessage <T> Request <T>(string url, HttpMethod method, StringContent content = null, ContentResponseType?contentResponseType = null, IDictionary <string, string> defaultRequestHeaders = null, IList <MediaTypeWithQualityHeaderValue> acceptRequestHeaders = null)
{
HttpRequestMessage message = new HttpRequestMessage(method, url);
var httpClient = new HttpClient();
foreach (var header in defaultRequestHeaders ?? Enumerable.Empty <KeyValuePair <string, string> >())
{
httpClient.DefaultRequestHeaders.Add(header.Key, header.Value);
}
foreach (var acceptHeader in acceptRequestHeaders ?? Enumerable.Empty <MediaTypeWithQualityHeaderValue>())
{
httpClient.DefaultRequestHeaders.Accept.Add(acceptHeader);
}
if (content != null)
{
message.Content = content;
}
var responseMessage = httpClient.SendAsync(message).Result;
ApiResponseMessage <T> apiResponseMessage = new ApiResponseMessage <T>()
{
ResponseMessage = responseMessage
};
if (responseMessage.IsSuccessStatusCode)
{
if (contentResponseType.HasValue && contentResponseType.Value == ContentResponseType.JsonContent)
{
string jsonString = responseMessage.Content.ReadAsStringAsync().Result;
var responseObject = Newtonsoft.Json.JsonConvert.DeserializeObject <T>(jsonString);
apiResponseMessage.ReponseObject = responseObject;
}
else if (contentResponseType.HasValue && contentResponseType.Value == ContentResponseType.TextContent)
{
string textString = responseMessage.Content.ReadAsStringAsync().Result;
apiResponseMessage.ReponseObject = (dynamic)textString;
}
else if (contentResponseType.HasValue && contentResponseType.Value == ContentResponseType.XmlContent)
{
string xmlString = responseMessage.Content.ReadAsStringAsync().Result;
apiResponseMessage.ReponseObject = xmlString.XmlDeserialize <T>();
}
}
return(apiResponseMessage);
}
public IActionResult GetArticles()
{
ApiResponseMessage <List <ArticleDTO> > apiResponseMessage = new ApiResponseMessage <List <ArticleDTO> >()
{
Succeed = false, Message = "", Data = null
};
var model = _mapper.Map <List <ArticleDTO> >(_articleRepository.GetArticles());
if (model.Count > 0)
{
apiResponseMessage.Succeed = true;
apiResponseMessage.Message = $"Islem basarili donen kayit sayisi: {model.Count}";
apiResponseMessage.Data = model;
}
return(Ok(apiResponseMessage));
}
/// <summary>
/// GetProductGroupDateTotalUsageAmountById
/// </summary>
/// <param name="usageaccountid">usageaccountid</param>
/// <returns> ApiResponseMessage ProductViewModel List</returns>
public static ApiResponseMessage <List <ProductViewModel> > GetProductGroupDateTotalUsageAmountById(string usageaccountid, int pageCnt, int pageRows)
{
Logger.Debug("Start GetProductGroupDateTotalUsageAmountById");
ApiResponseMessage <List <ProductViewModel> > response = new ApiResponseMessage <List <ProductViewModel> >();
List <ProductViewModel> result = response.Data;
try
{
response = GetProductGroupDateTotalUsageAmount(usageaccountid, pageCnt, pageRows);
response.StatusCode = System.Net.HttpStatusCode.OK;
}
catch (Exception ex)
{
Logger.Error(ex);
response.StatusCode = System.Net.HttpStatusCode.InternalServerError;
response.Errors.Add(new System.Web.Http.HttpError(ex, false));
}
Logger.Debug("End GetProductGroupDateTotalUsageAmountById");
return(response);
}
/// <summary>
/// GetProductGroupTotalUsageAmount
/// </summary>
/// <param name="pageCnt">查詢的頁數</param>
/// <param name="pageRows">每頁筆數</param>
/// <returns> ApiResponseMessageProductViewModel List</returns>
private static ApiResponseMessage <List <ProductViewModel> > GetProductGroupTotalUsageAmount(string usageaccountid, int pageCnt, int pageRows)
{
var result = new ApiResponseMessage <List <ProductViewModel> >();
var resultData = GetProducts().Join(GetLineItems(), p => p.Id, l => l.ProductId, (p, l) => new { p, l })
.Where(x => x.l.UsageAccountId == usageaccountid)
.GroupBy(g => g.p.ProductName)
.Select(s => new ProductViewModel
{
ProductName = s.Key,
TotalUsageAmount = s.Sum(t => t.l.UnblendedCost)
});
if (pageCnt != 0 && pageRows != 0)
{
resultData.Skip((pageCnt - 1) * pageRows).Take(pageRows);
}
result.Data = resultData.ToList();
return(result);
}
public IActionResult GetArticlesForAuthor(Guid authorId)
{
ApiResponseMessage <List <ArticleDTO> > apiResponseMessage = new ApiResponseMessage <List <ArticleDTO> >()
{
Succeed = false, Message = "", Data = null
};
var articlesForAuthor = _mapper.Map <List <ArticleDTO> >(_articleRepository.GetArticlesForAuthor(authorId));
if (articlesForAuthor != null)
{
apiResponseMessage.Succeed = true;
apiResponseMessage.Message = $"Islem basarili GetArticlesForAuthor";
apiResponseMessage.Data = articlesForAuthor;
}
else
{
return(NotFound());
}
return(Ok(apiResponseMessage));
}
public override void OnActionExecuting(HttpActionContext actionContext)
{
var modelState = actionContext.ModelState;
if (!modelState.IsValid)
{
string error = string.Empty;
foreach (var key in modelState.Keys)
{
var state = modelState[key];
if (state.Errors.Any())
{
var modelError = state.Errors.First();
if (modelError.Exception != null)
{
error = modelError.Exception.Message;
}
else
{
error = modelError.ErrorMessage;
if (error.Length < 1)
{
error = $"参数格式验证失败:[{key}]";
}
}
break;
}
}
ApiResponseMessage response = new ApiResponseMessage()
{
Status = ResultStatus.ParamError, Message = error
};
actionContext.Response = new HttpResponseMessage(HttpStatusCode.Accepted)
{
Content = new ObjectContent <ApiResponseMessage>(response,
actionContext.ActionDescriptor.Configuration.Formatters.JsonFormatter)
};
}
}
public async Task Trying_To_Read_Valid_CamelCase_Json_As_ApiResponseMessage_From_HttpContent_Async_Is_Successful()
{
// Arrange
HttpContent httpContent = new StringContent(
@"{ ""code"" : 200,
""message"": {""header"" : ""Test header"", ""body"" : ""Test body""},
""info"" : ""Extra info""
}");
var expectedApiResponseMessage = new ApiResponseMessage <ExampleMessageType>()
{
Code = (HttpStatusCode)200,
Message = new ExampleMessageType {
Header = "Test header", Body = "Test body"
},
Info = "Extra info"
};
// Act
ApiResponseMessage <ExampleMessageType> actualApiResponseMessage = null;
var result = await httpContent.TryReadAsApiResponseMessageAsync <ExampleMessageType>();
actualApiResponseMessage = result.ExpectedApiResponseMessage;
// Assert
if (!result.Success || actualApiResponseMessage == null)
{
Assert.Fail();
}
Assert.AreEqual(expectedApiResponseMessage.Code, actualApiResponseMessage.Code);
Assert.AreEqual(expectedApiResponseMessage.Message.Header, actualApiResponseMessage.Message.Header);
Assert.AreEqual(expectedApiResponseMessage.Message.Body, actualApiResponseMessage.Message.Body);
Assert.AreEqual(expectedApiResponseMessage.Info, actualApiResponseMessage.Info);
}
//para funcionar o binding de um xml para um array ou list a classe correspondente ao parâmetro
//deve ser decorada com a propriedade "[DataContract]" e as propriedades da classe que precisam
//ser serializadas devem ser decoradas com a propriedade "[DataMember]"
//Se na origem da requisição o dado for um json isto não é necessário.
//Ver explicação em: http://www.asp.net/web-api/overview/formats-and-model-binding/json-and-xml-serialization
public HttpResponseMessage NovaRequisicao([FromBody] RequisicaoDeCompraVm requisicaoDeCompraVm)
{
ApiResponseMessage retornoPortal;
try
{
_cadastroRequisicaoCompra.NovaRequisicao(requisicaoDeCompraVm);
retornoPortal = new ApiResponseMessage()
{
Retorno = new Retorno()
{
Codigo = "200", Texto = "Requisição de compra criada com sucesso."
}
};
return(Request.CreateResponse(HttpStatusCode.OK, retornoPortal));
}
catch (Exception ex)
{
retornoPortal = ExceptionUtil.GeraExecaoDeErroParaWebApi(ex);
return(Request.CreateResponse(HttpStatusCode.OK, retornoPortal));
}
}
//para funcionar o binding de um xml para um array ou list a classe correspondente ao parâmetro
//deve ser decorada com a propriedade "[DataContract]" e as propriedades da classe que precisam
//ser serializadas devem ser decoradas com a propriedade "[DataMember]"
//Se na origem da requisição o dado for um json isto não é necessário.
//Ver explicação em: http://www.asp.net/web-api/overview/formats-and-model-binding/json-and-xml-serialization
public HttpResponseMessage PostMultiplo([FromBody] ListaFornecedores fornecedores)
{
ApiResponseMessage retornoPortal;
try
{
var fornecedoresComNome = fornecedores.Where(x => !string.IsNullOrEmpty(x.Nome)).ToList();
int quantidadeDeFornecedoresSemNome = fornecedores.Count - fornecedoresComNome.Count;
_cadastroFornecedor.AtualizarFornecedores(fornecedoresComNome);
retornoPortal = new ApiResponseMessage()
{
Retorno = new Retorno() {Codigo = "200", Texto = fornecedoresComNome.Count + " fornecedores atualizados." +
(quantidadeDeFornecedoresSemNome > 0 ? quantidadeDeFornecedoresSemNome + " fornecedores não atualizados: " +
string.Join(", ",fornecedores.Where(x => string.IsNullOrEmpty(x.Nome)).Select(f => f.Codigo)) + ".": "") }
};
return Request.CreateResponse(HttpStatusCode.OK, retornoPortal);
}
catch (Exception ex)
{
retornoPortal = ExceptionUtil.GeraExecaoDeErroParaWebApi(ex);
return Request.CreateResponse(HttpStatusCode.OK, retornoPortal);
}
}
//para funcionar o binding de um xml para um array ou list a classe correspondente ao parâmetro
//deve ser decorada com a propriedade "[DataContract]" e as propriedades da classe que precisam
//ser serializadas devem ser decoradas com a propriedade "[DataMember]"
//Se na origem da requisição o dado for um json isto não é necessário.
//Ver explicação em: http://www.asp.net/web-api/overview/formats-and-model-binding/json-and-xml-serialization
public HttpResponseMessage PostMultiplo([FromBody] ListaIva ivas)
{
ApiResponseMessage retornoPortal;
try
{
_cadastroIva.AtualizarIvas(ivas);
retornoPortal = new ApiResponseMessage()
{
Retorno = new Retorno()
{
Codigo = "200", Texto = ivas.Count + " Ivas atualizados"
}
};
return(Request.CreateResponse(HttpStatusCode.OK, retornoPortal));
}
catch (Exception ex)
{
retornoPortal = ExceptionUtil.GeraExecaoDeErroParaWebApi(ex);
return(Request.CreateResponse(HttpStatusCode.OK, retornoPortal));
}
}
//para funcionar o binding de um xml para um array ou list a classe correspondente ao parâmetro
//deve ser decorada com a propriedade "[DataContract]" e as propriedades da classe que precisam
//ser serializadas devem ser decoradas com a propriedade "[DataMember]"
//Se na origem da requisição o dado for um json isto não é necessário.
//Ver explicação em: http://www.asp.net/web-api/overview/formats-and-model-binding/json-and-xml-serialization
public HttpResponseMessage PostMultiplo([FromBody] ListaUnidadesDeMedida unidadesDeMedida)
{
ApiResponseMessage retornoPortal;
try
{
_cadastroUnidadeDeMedida.AtualizarUnidadesDeMedida(unidadesDeMedida);
retornoPortal = new ApiResponseMessage()
{
Retorno = new Retorno()
{
Codigo = "200", Texto = unidadesDeMedida.Count + " unidades de medida atualizadas"
}
};
return(Request.CreateResponse(HttpStatusCode.OK, retornoPortal));
}
catch (Exception ex)
{
retornoPortal = ExceptionUtil.GeraExecaoDeErroParaWebApi(ex);
return(Request.CreateResponse(HttpStatusCode.OK, retornoPortal));
}
}
//para funcionar o binding de um xml para um array ou list a classe correspondente ao parâmetro
//deve ser decorada com a propriedade "[DataContract]" e as propriedades da classe que precisam
//ser serializadas devem ser decoradas com a propriedade "[DataMember]"
//Se na origem da requisição o dado for um json isto não é necessário.
//Ver explicação em: http://www.asp.net/web-api/overview/formats-and-model-binding/json-and-xml-serialization
public HttpResponseMessage PostMultiplo([FromBody] ListaCondicaoPagamento condicoesDePagamento)
{
ApiResponseMessage retornoPortal;
try
{
_cadastroCondicaoPagamento.AtualizarCondicoesDePagamento(condicoesDePagamento);
retornoPortal = new ApiResponseMessage()
{
Retorno = new Retorno()
{
Codigo = "200", Texto = condicoesDePagamento.Count + " condições de pagamento atualizadas"
}
};
return(Request.CreateResponse(HttpStatusCode.OK, retornoPortal));
}
catch (Exception ex)
{
retornoPortal = ExceptionUtil.GeraExecaoDeErroParaWebApi(ex);
return(Request.CreateResponse(HttpStatusCode.OK, retornoPortal));
}
}
protected async Task <OkObjectResult> ResponseData(bool isSuccess, dynamic dataResponse, ApiResponseMessage message)
{
ResponseViewModel response = new ResponseViewModel()
{
IsSuccess = isSuccess,
Message = message.Message,
Data = dataResponse
};
return(await Task.FromResult(Ok(response.ToJsonCamel())));
}
