public static PagamentoDto GetNewPagamento(PagamentoUnificatoFatturaAcquistoDto pagamenoUnificatoFatturaAcquisto)
{
try
{
if (pagamenoUnificatoFatturaAcquisto != null)
{
var fatturaAcquisto = pagamenoUnificatoFatturaAcquisto.FatturaAcquisto;
var pagamentoUnificato = pagamenoUnificatoFatturaAcquisto.PagamentoUnificato;
var pagamento = new PagamentoDto();
pagamento.Codice = GetCodice(fatturaAcquisto);
pagamento.Data = pagamentoUnificato.Data;
pagamento.Descrizione = pagamentoUnificato.Descrizione;
pagamento.FatturaAcquistoId = pagamenoUnificatoFatturaAcquisto.FatturaAcquistoId;
pagamento.Importo = pagamenoUnificatoFatturaAcquisto.Saldo;
pagamento.TransazionePagamento = pagamenoUnificatoFatturaAcquisto.TransazionePagamento;
pagamento.Note = "Pagamento unificato " + BusinessLogic.PagamentoUnificato.GetCodifica(pagamentoUnificato);
pagamento.PagamentoUnificatoId = pagamenoUnificatoFatturaAcquisto.PagamentoUnificatoId;
pagamento.TipoPagamento = pagamentoUnificato.TipoPagamento;
return(pagamento);
}
}
catch (Exception ex)
{
UtilityError.Write(ex);
}
return(null);
}
public IActionResult Post(
[FromServices] BackendTestContext context,
[FromBody] PagamentoDto model)
{
try
{
int mes, ano;
string estado;
Regex regex = new Regex(@"(?<Mes>\d{2})/(?<Ano>\d{4})");
Match match = regex.Match(model.Cartao.Data_Expiracao);
mes = Int32.Parse(match.Groups["Mes"].Value);
ano = Int32.Parse(match.Groups["Ano"].Value);
DateTime now = DateTime.Now;
// Checando o valor e a data de vencimento do cartão
if (model.Valor > 100 && (ano > now.Year || (ano == now.Year && mes >= now.Month)))
{
estado = "APROVADO";
}
else
{
estado = "REJEITADO";
}
var resposta = new { Valor = model.Valor, Estado = estado };
return(Ok(resposta));
}
catch
{
return(BadRequest("Ocorreu um erro desconhecido"));
}
}
public IActionResult RealizaPagamento(PagamentoPost pagamentoPost)
{
PagamentoDto pagamentoDto = new PagamentoDto
{
Id = Guid.NewGuid(),
DataSolicitacao = DateTimeOffset.Now,
DataAprovacao = null,
StatusPagamento = StatusPagamentoDto.Processando,
Valor = pagamentoPost.Valor
};
return(Ok(pagamentoDto));
}
public IActionResult ObtemPagamento(Guid id)
{
PagamentoDto pagamentoDto = new PagamentoDto
{
Id = Guid.NewGuid(),
DataSolicitacao = DateTimeOffset.Now,
DataAprovacao = null,
StatusPagamento = StatusPagamentoDto.Processando,
Valor = 1234.12
};
return(Ok(pagamentoDto));
}
public static string GetCodifica(PagamentoDto pagamento)
{
try
{
if (pagamento != null)
{
var codifica = pagamento.Codice + " DEL " + UtilityValidation.GetDataND(pagamento.Data);
return(codifica);
}
}
catch (Exception ex)
{
UtilityError.Write(ex);
}
return(null);
}
public async Task <ActionResult> Compras([FromBody] PagamentoDto pagamento)
{
if (!ModelState.IsValid)
{
return(StatusCode((int)HttpStatusCode.BadRequest, "Ocorreu um Erro Desconhecido"));
}
var retorno = await _service.RequestExterno(pagamento);
if (_error.ErrorMessages.Any())
{
return(BadRequest(_error.ErrorMessages));
}
if (retorno == null)
{
return(StatusCode((int)HttpStatusCode.BadRequest, "Ocorreu um Erro Desconhecido"));
}
return(Ok(retorno));
}
public async Task <IActionResult> Post(
[FromServices] BackendTestContext context,
[FromBody] CompraDto model)
{
try
{
HttpClientHandler clientHandler = new HttpClientHandler();
clientHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => { return(true); };
// O gateway fornecido (http://sv-dev-01.pareazul.com.br:8080/api/gateways/compras) não conseguiu ser acessado
// e por tanto decidi por usar a api de pagamentos implementada no item 6 como gateway
Uri link = new Uri("http://127.0.0.1:5000/api/pagamento/compras");
var client = new HttpClient(clientHandler);
Produto produto = await context.Produtos.AsNoTracking().FirstOrDefaultAsync(p => p.Id == model.Produto_Id);
if (produto == null || produto.QtdeEstoque < model.Qtde_Comprada)
{
return(BadRequest("Ocorreu um erro desconhecido"));
}
PagamentoDto pagamento = new PagamentoDto()
{
Valor = produto.ValorUnitario * model.Qtde_Comprada,
Cartao = model.Cartao
};
var jsonInString = JsonConvert.SerializeObject(pagamento);
var httpResponse = await client.PostAsync(link, new StringContent(jsonInString, Encoding.UTF8, "application/json"));
httpResponse.EnsureSuccessStatusCode();
string respostaEmString = await httpResponse.Content.ReadAsStringAsync();
dynamic gatewayJson = JsonConvert.DeserializeObject(respostaEmString);
DateTime now = DateTime.Now;
// Atualizando a quantidade de estoque do produto e a data de atualização
produto.QtdeEstoque = produto.QtdeEstoque - model.Qtde_Comprada;
produto.DataAtualizacao = now;
context.Entry(produto).State = EntityState.Modified;
// Cadastrando a transação
Transacao transacao = new Transacao()
{
ProdutoId = model.Produto_Id,
ValorVenda = gatewayJson.valor,
DataVenda = now,
Estado = gatewayJson.estado
};
context.Transacoes.Add(transacao);
await context.SaveChangesAsync();
return(Ok("Venda realizada com sucesso"));
}
catch
{
return(BadRequest("Ocorreu um erro desconhecido"));
}
}
private static void AddReportPagamentoFornitore(UtilityReport.Table tablePagamenti, PagamentoDto pagamento)
{
try
{
if (pagamento != null)
{
var numero = pagamento.Codice;
var data = UtilityValidation.GetDataND(pagamento.Data);
var tipoPagamento = pagamento.TipoPagamento;
var descrizione = pagamento.Descrizione;
var note = pagamento.Note;
var transazionePagamento = (pagamento.TransazionePagamento != null ? pagamento.TransazionePagamento.ToUpper() : "");
var importo = UtilityValidation.GetEuro(pagamento.Importo);
tablePagamenti.AddRow(numero, data, tipoPagamento, descrizione, note, transazionePagamento, importo);
}
}
catch (Exception ex)
{
UtilityError.Write(ex);
}
}
public async Task <RequestExternoDto> RequestExterno(PagamentoDto pagamento)
{
if (pagamento.Cartao.cvv.Length != 3 || pagamento.Cartao.numero.Length != 16)
{
_error.ErrorMessages.Add(new ErrorMessage
{
StatusCode = HttpStatusCode.PreconditionFailed,
Message = "Os valores informados não são válidos"
});
}
var bandeiracartao = new List <string> {
"VISA", "Mastercard", "AMEX", "Diners Club", "Discover", "Hipercard", "Inter"
};
if (!bandeiracartao.Contains(pagamento.Cartao.bandeira))
{
_error.ErrorMessages.Add(new ErrorMessage
{
StatusCode = HttpStatusCode.PreconditionFailed,
Message = "Não aceitamos essa bandeira"
});
}
string[] date = pagamento.Cartao.data_expiracao.Split('/');
if (int.Parse(date[1]) < DateTime.Now.Year)
{
_error.ErrorMessages.Add(new ErrorMessage
{
StatusCode = HttpStatusCode.PreconditionFailed,
Message = "Data do Cartão Expirada"
});
}
if (int.Parse(date[0]) < DateTime.Now.Month && int.Parse(date[1]) == DateTime.Now.Month)
{
_error.ErrorMessages.Add(new ErrorMessage
{
StatusCode = HttpStatusCode.PreconditionFailed,
Message = "Data do Cartão Expirada"
});
}
var getproduct = await Get(pagamento.produto_id);
if (getproduct.qtde_estoque < pagamento.qtde_comprada)
{
_error.ErrorMessages.Add(new ErrorMessage
{
StatusCode = HttpStatusCode.PreconditionFailed,
Message = "Quantidade Insuficiente no estoque"
});
}
var prepararpagamento = pagamento.qtde_comprada * getproduct.valor_unitario;
var pagamentosend = new PagamentoExternoSend
{
valor = prepararpagamento,
cartao = pagamento.Cartao
};
var data = JsonConvert.SerializeObject(pagamentosend);
var content = new StringContent(data, Encoding.UTF8, "application/json");
var response = await HttpClient.PostAsync(_comprasUrl, content);
var retorno = JsonConvert.DeserializeObject <RequestExternoDto>(response.Content.ReadAsStringAsync().Result);
if (retorno.estado == "Aprovado")
{
getproduct.DataUltCompra = DateTime.UtcNow;
getproduct.ValorUltVenda = retorno.valor;
getproduct.qtde_estoque = getproduct.qtde_estoque - pagamento.qtde_comprada;
var model = _mapper.Map <ProductModel>(getproduct);
var entity = _mapper.Map <ProductEntity>(model);
await _productrepository.UpdateAsync(entity);
}
return(retorno);
}