public ActionResult <string> Post([FromBody] PagamentoViewModel pagamento)
{
IsolationLevel isolationLevel = IsolationLevel.ReadUncommitted;
ServicoFactory factory = ServicoFactory.Create(isolationLevel);
var Pagamento = factory.getPagamento();
IPagamentoDominio pagamentoDominio = new PagamentoViewModel();
pagamentoDominio.Descricao = pagamento.Descricao;
pagamentoDominio.Email = pagamento.Email;
pagamentoDominio.FormaPagamento = pagamento.FormaPagamento;
pagamentoDominio.Nome = pagamento.Nome;
pagamentoDominio.Status = "AT";
pagamentoDominio.Telefone = pagamento.Telefone;
foreach (var item in pagamento.PagamentoItemViewModels)
{
IPagamentoItemDominio pagamentoItem = new PagamentoItemViewModel();
pagamentoItem.Quantidade = item.Quantidade;
pagamentoItem.Status = "AT";
pagamentoItem.ServicoDominioId = item.ServicoDominioId;
pagamentoDominio.IPagamentoItemDominios.Add(pagamentoItem);
}
var pagamentoRetorno = Pagamento.Incluir(pagamentoDominio).Result;
pagamentoRetorno.IPagamentoItemDominios = null;
return(Ok(pagamentoRetorno));
}
public PagamentosView()
{
viewModel = new PagamentoViewModel();
InitializeComponent();
DataContext = viewModel;
}
public async Task <IActionResult> Insert([FromBody] PagamentoViewModel model)
{
if (model == null)
{
return(BadRequest("Pagamento precisa ser informado"));
}
try
{
await _PagamentoService.Adicionar(new Pagamento()
{
ClienteID = model.ClientID,
Data = DateTime.Now,
EstabelecimentoID = model.EstabelecimentoID,
IsCanceled = false,
Valor = model.Valor
});
var newpayment = await _PagamentoService.ObterMaisRecente();
return(CreatedAtRoute("GetPagamento", new { id = newpayment.Id }, newpayment));
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult FormCreatePagamento(PagamentoViewModel entrada)
{
Pagamento pagamento = new Pagamento();
try
{
if (entrada.pagamento != null)
{
if (PagamentoRules.ValidaCreate(entrada, contasReceberData))
{
if (PagamentoRules.PagamentoCreate(entrada, out pagamento, contexto))
{
pagamentoData.Add(pagamento);
ContasReceberRules.CalculoPagamento(entrada.contasReceber.id, pagamentoData, contasReceberData);
return(RedirectToAction("FormUpdateContasReceber", "ContasReceber", new { id = entrada.contasReceber.id.ToString() }));
}
}
else
{
return(RedirectToAction("MensagemPagamento", "Pagamento", new { idContasReceber = entrada.contasReceber.id.ToString() }));
}
}
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 12, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormCreatePagamento-post", ex.Message);
}
return(View());
}
public static bool PagamentoCreate(PagamentoViewModel entrada, out Pagamento pagamento, ContextPage contexto)
{
pagamento = new Pagamento();
pagamento = entrada.pagamento;
if (entrada.contasReceber != null)
{
pagamento = entrada.pagamento;
pagamento.idContasReceber = entrada.contasReceber.id;
pagamento.dataPagamento = DateTime.Now;
//************ Objetos de controle de acesso ******************
pagamento.criadoEm = DateTime.Now;
pagamento.criadoPor = contexto.idUsuario;
pagamento.criadoPorName = contexto.nomeUsuario;
pagamento.modificadoEm = DateTime.Now;
pagamento.modificadoPor = contexto.idUsuario;
pagamento.modificadoPorName = contexto.nomeUsuario;
pagamento.idOrganizacao = contexto.idOrganizacao;
//************ FIM Objetos de controle de acesso ***************
return(true);
}
return(false);
}
public ActionResult RealizarPagamento(PagamentoViewModel pagamentoViewModel)
{
TempData["Menu"] = "pagamentos";
if (!ModelState.IsValid)
return View(pagamentoViewModel);
try
{
pagamentoViewModel.DataPagamento = DateTime.Now;
Pagamento pagamento = Mapper.Map<PagamentoViewModel, Pagamento>(pagamentoViewModel);
_pagamentoAppService.Add(pagamento);
}
catch (DbEntityValidationException ex)
{
string errors = "";
foreach (var eve in ex.EntityValidationErrors)
{
errors += "Entity of type " + eve.Entry.Entity.GetType().Name + " in state " + eve.Entry.State + " has the following validation errors:\n";
foreach (var ve in eve.ValidationErrors)
{
errors += "- Property: " + ve.PropertyName + ", Error: " + ve.ErrorMessage + "\n";
}
}
throw new Exception(errors);
}
catch (Exception ex)
{
throw ex;
}
return RedirectToAction("HistoricoPagamentos");
}
public IActionResult Pagamento([FromForm] PagamentoViewModel pagamento)
{
if (ModelState.IsValid)
{
Parcelamento parcela = BuscarParcelamento(pagamento.Aluguel, pagamento.Parcelamento.Numero);
try
{
Transaction transacao = _pagar.GerarPagCartaoCredito(pagamento.CartaoCredito, pagamento.Aluguel, parcela);
ProcessarPedido(transacao, pagamento.Aluguel);
TempData["MSG_S"] = Mensagem.MSG_S001;
return(RedirectToAction(nameof(Index)));
}
catch (PagarMeException e)
{
_logger.LogError(e, "PagamentoController > Index");
TempData["MSG_S"] = MontarMensagensDeErro(e);
return(RedirectToAction(nameof(Index)));
}
}
else
{
return(View());
}
}
public ActionResult EditarPagamento(PagamentoViewModel pagamento, string token)
{
if (pagamento.ValorPagamento < 0)
{
return(Content("O valor do pagamento não deve ser negativo!"));
}
var response = _appPagamento.EditarPagamento(pagamento, token);
if (response.Status != HttpStatusCode.OK)
{
return(Content("Erro. " + response.ContentAsString));
}
if (!Session["Login"].ToString().Equals(pagamento.Usuario.Cpf))
{
return(Content("Pagamento editado com sucesso!!"));
}
var user = _appUsuario.SelecionarUsuario(pagamento.Usuario.Cpf);
if (user.Status != HttpStatusCode.OK)
{
return(Content("Erro ao atualizar seu saldo"));
}
Session["saldoUsuario"] = $"{user.Content.SaldoUsuario:C}";
return(Content("Pagamento editado com sucesso!!"));
}
public ActionResult InserirPagamento(PagamentoViewModel pagamento, string token)
{
if (pagamento.ValorPagamento < 0)
{
return(Content("O valor do pagamento não deve ser negativo!"));
}
pagamento.Usuario = new UsuarioViewModel {
Cpf = Session["login"].ToString()
};
var response = _appPagamento.InserirPagamento(pagamento, token);
if (response.Status == HttpStatusCode.OK)
{
var res = _appUsuario.SelecionarUsuario(Session["login"].ToString());
if (response.Status != HttpStatusCode.OK)
{
return(Content("Erro ao atualizar saldo, " + response.ContentAsString));
}
Session["saldoUsuario"] = $"{res.Content.SaldoUsuario:C}";
}
else
{
return(Content("Erro. " + response.ContentAsString));
}
return(Content("Pagamento realizado com sucesso!!"));
}
public async Task <ActionResult> AutorizarPagamento(PagamentoViewModel pagamentoViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(new
{
sucess = false,
valor = pagamentoViewModel.Valor,
estado = "REJEITADA"
}));
}
var IsAuthorized = await _autorizarCompraService.AutorizarCompra(_mapper.Map <Pagamento>(pagamentoViewModel));
if (!IsAuthorized)
{
return(BadRequest(new
{
sucess = false,
valor = pagamentoViewModel.Valor,
estado = "REJEITADA"
}));
}
return(Ok
(new
{
sucess = true,
valor = pagamentoViewModel.Valor,
estado = "APROVADA"
}));
}
public async Task <IActionResult> Payment(Guid id, PagamentoViewModel pagamento)
{
var duplicata = _duplicataApplicationService.GetById(id);
if (duplicata == null || duplicata.Pagamento != null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
NotifyModelStateErrors();
return(View(pagamento));
}
var commandResult = await _duplicataApplicationService.Pagar(duplicata, pagamento);
if (commandResult.Success)
{
NotifyCommandResultSuccess();
return(RedirectToAction(nameof(Details), new { id }));
}
else
{
NotifyCommandResultErrors(commandResult.Errors);
}
return(View(pagamento));
}
//private SeguroViagemContexto db = new SeguroViagemContexto();
public ActionResult Index(PagamentoViewModel pagamentoViewModel)
{
if (ModelState.IsValid)
{
return(Json(new { formValido = true }));
}
return(PartialView("Index", pagamentoViewModel));
}
public ActionResult Payment(PagamentoViewModel model)
{
model.WebSite = Request.UrlReferrer.Host;
model.UrlRequest = Request.UrlReferrer.OriginalString;
try
{
// verifico se non è un test locale
if (Session["testPaymentFromLocalHost"] != null)
{
model.WebSite = "http://www.gratisforgratis.com";
model.UrlRequest = "/Home/Index";
model.Token = System.Configuration.ConfigurationManager.AppSettings["test"];
model.Test = 1;
}
using (DatabaseContext db = new DatabaseContext())
{
// verifica autenticità del portale web tramite dominio e token
ATTIVITA sito = db.ATTIVITA.FirstOrDefault(m => m.DOMINIO == model.WebSite && m.TOKEN == new Guid(model.Token));
if (sito != null)
{
SalvataggioPagamentoViewModel salvataggioPagamento = new SalvataggioPagamentoViewModel(model);
salvataggioPagamento.PortaleWebID = sito.ID_CONTO_CORRENTE;
// verifica se l'utente è registrato
PERSONA utentePagato = db.PERSONA.FirstOrDefault(m => m.PERSONA_EMAIL.SingleOrDefault(item => item.TIPO == (int)TipoEmail.Registrazione).EMAIL == model.EmailReceivent);
if (utentePagato != null)
{
salvataggioPagamento.UtentePagatoID = utentePagato.ID_CONTO_CORRENTE;
Session["pagamento"] = salvataggioPagamento;
}
else
{
ModelState.AddModelError("Error", Language.ErrorNotUser);
if (!String.IsNullOrEmpty(model.ReturnUrlForFailed))
{
return(Redirect(model.ReturnUrlForFailed));
}
}
}
else
{
ModelState.AddModelError("Error", Language.ErrorNotPartner);
if (!String.IsNullOrEmpty(model.ReturnUrlForFailed))
{
return(Redirect(model.ReturnUrlForFailed));
}
}
}
}
catch (Exception ex)
{
Elmah.ErrorSignal.FromCurrentContext().Raise(ex);
ModelState.AddModelError("Error", ex.Message);
}
return(View(model));
}
public IActionResult Payment(Guid id)
{
var pagamentoViewModel = new PagamentoViewModel()
{
DuplicataId = id
};
return(View(pagamentoViewModel));
}
public ViewResult MensagemPagamento(string idContasReceber)
{
PagamentoViewModel modelo = new PagamentoViewModel();
modelo.contasReceber = new Relacao();
modelo.contasReceber.id = new Guid(idContasReceber);
return(View(modelo));
}
public static Pagamento ToPagamento(PagamentoViewModel pagamentoViewModel)
{
var pagamento = new Pagamento(
pagamentoViewModel.PagamentoId,
pagamentoViewModel.Valor,
pagamentoViewModel.AlunoId,
pagamentoViewModel.PedidoId);
return(pagamento);
}
public ActionResult RealizarPagamento()
{
TempData["Menu"] = "pagamentos";
PagamentoViewModel pagamentoViewModel = new PagamentoViewModel()
{
ListaFuncionarios = Mapper.Map<List<Funcionario>, List<FuncionarioModel>>(_funcionarioAppService.GetAll()),
ListaTiposPagamento = Mapper.Map<List<TipoPagamento>, List<TipoPagamentoModel>>(_pagamentoAppService.BuscarTiposPagamento()),
};
return View(pagamentoViewModel);
}
// GET: Pagamento
//public ActionResult ContasAReceberDetalhe(int id)
//{
// ContasAPagar contas = new ContasAPagar();
// var aReceber = (from cli in db.Clientes
// join gru in db.Grupos on cli.Grupo_id equals gru.Grupo_id
// join com in db.Comissoes on cli.Grupo_id equals com.Grupo_id
// join rep in db.Representacoes on cli.Representacao_id equals rep.Representacao_id
// select new ContasAPagarViewModel
// {
// Nome = gru.Nome,
// nome1 = rep.Nome,
// Nu_parcelas = gru.Nu_parcelas,
// Valor_Credito = cli.Valor_Credito,
// Rep_1 = (cli.Valor_Credito * com.Rep_1 / 100),
// Rep_2 = (cli.Valor_Credito * com.Rep_2 / 100),
// Rep_3 = (cli.Valor_Credito * com.Rep_3 / 100),
// Rep_4 = (cli.Valor_Credito * com.Rep_4 / 100),
// Rep_5 = (cli.Valor_Credito * com.Rep_5 / 100),
// Rep_6 = (cli.Valor_Credito * com.Rep_6 / 100),
// ClienteId = cli.ClienteId
// });
// aReceber = aReceber.Where(x => x.ClienteId.Equals(id));
// return View(aReceber);
//}
public ActionResult Create(int id)
{
Cliente cliente = db.Clientes.Find(id);
ViewBag.Grupos = db.Grupos.Find(cliente.Grupo_id).Nome;
ViewBag.Cliente = db.Clientes.Find(cliente.ClienteId).Nome;
var model = new PagamentoViewModel();
return(View(model));
}
public static PagamentoCartao ToPagamentoCartao(PagamentoViewModel pagamentoViewModel)
{
var pagamentoCartao = new PagamentoCartao(
pagamentoViewModel.NumeroCartao,
pagamentoViewModel.NomeCartao,
pagamentoViewModel.MesVencimento,
pagamentoViewModel.AnoVencimento,
pagamentoViewModel.CodigoSeguranca);
return(pagamentoCartao);
}
public override void Init()
{
try
{
ViewModel = new PagamentoViewModel();
}
catch (Exception ex)
{
UtilityError.Write(ex);
}
}
public IActionResult Pagamento(int id)
{
var pagamento = new PagamentoViewModel {
Aluguel = _aluguelRepository.ObterAluguel(id)
};
DateTime data = DateTime.ParseExact(pagamento.Aluguel.DataPrevista, "yyyy/MM/dd", CultureInfo.InvariantCulture);
pagamento.Aluguel.DataPrevista = data.ToString("dd/MM/yyyy");
ViewBag.Parcelamentos = CalcularParcelamento(pagamento.Aluguel);
return(View(pagamento));
}
public Response <IEnumerable <PagamentoViewModel> > ListarPagamentosUsuarios(PagamentoViewModel pagamento, string token)
{
using (var client = new HttpClient())
{
AtualizaToken(token, client);
var response = client.PostAsync(_enderecoApi + "/PagamentoUsuario", pagamento, new JsonMediaTypeFormatter()).Result;
return(response.StatusCode != HttpStatusCode.OK
? new Response <IEnumerable <PagamentoViewModel> >(response.Content.ReadAsStringAsync().Result, response.StatusCode)
: new Response <IEnumerable <PagamentoViewModel> >(response.StatusCode));
}
}
public Response <string> EditarPagamento(PagamentoViewModel pagamento, string token)
{
using (var client = new HttpClient())
{
AtualizaToken(token, client);
var response = client.PutAsync(_enderecoApi, pagamento, new JsonMediaTypeFormatter()).Result;
return(response.StatusCode != HttpStatusCode.OK
? new Response <string>(response.Content.ReadAsStringAsync().Result, response.StatusCode)
: new Response <string>(response.StatusCode));
}
}
public ActionResult Checkout(PagamentoViewModel pagamentoViewModel)
{
var pedido = _pedidoAppService.ObterPedidoPendente(AlunoId);
pagamentoViewModel.PedidoId = pedido.PedidoId;
pagamentoViewModel.Pedido = pedido;
pagamentoViewModel.Valor = pedido.PedidoItems.Sum(p => p.Valor);
_pagamentoAppService.Adicionar(pagamentoViewModel);
return(ValidarErrosDominio() ? View(pagamentoViewModel) : View("Confirmacao", pagamentoViewModel));
}
//public ActionResult Dados(ImpressaoViewModel impressaoViewModel)
//{
// return View(impressaoViewModel);
//}
public ActionResult Imprimir(PagamentoViewModel pagamentoViewModel)
{
var impressaoViewModel = new GeradorApolice().GerarApolice(pagamentoViewModel);
var relatorioPDF = new ViewAsPdf
{
ViewName = "Dados",
IsGrayScale = true,
Model = impressaoViewModel
};
return(relatorioPDF);
}
public ViewResult FormCreatePagamento(string idContasReceber)
{
PagamentoViewModel modelo = new PagamentoViewModel();
modelo.pagamento = new Pagamento();
modelo.contexto = contexto;
modelo.pagamento.criadoEm = DateTime.Now;
modelo.pagamento.criadoPorName = contexto.nomeUsuario;
modelo.contasReceber = new Relacao();
modelo.contasReceber.id = new Guid(idContasReceber);
modelo.pagamento.valor = contasReceberData.Get(new Guid(idContasReceber)).valorRestante;
return(View(modelo));
}
public ActionResult Edit([Bind(Include = "Id,UsuarioId,Tipo,InformacoesPagamento")] PagamentoViewModel pagamento)
{
new MapperConfiguration(map => { map.CreateMap <PagamentoViewModel, Pagamento>(); });
var model = Mapper.Map <PagamentoViewModel, Pagamento>(pagamento);
if (ModelState.IsValid)
{
db.Entry(model).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(pagamento));
}
public ActionResult Checkout()
{
var pedido = _pedidoAppService.ObterPedidoPendente(AlunoId);
var pagamento = new PagamentoViewModel()
{
AlunoId = AlunoId,
Valor = pedido.PedidoItems.Sum(p => p.Valor),
PedidoId = pedido.PedidoId,
Pedido = pedido
};
return(View(pagamento));
}
public static bool PagamentoUpdate(PagamentoViewModel entrada, out Pagamento pagamento)
{
pagamento = new Pagamento();
//************ Objetos de controle de acesso *******************
pagamento.dataPagamento = DateTime.Now;
pagamento.modificadoEm = DateTime.Now;
pagamento.modificadoPor = entrada.contexto.idUsuario;
pagamento.modificadoPorName = entrada.contexto.nomeUsuario;
//************ FIM Objetos de controle de acesso ***************
return(true);
}
public static bool ValidaCreate(PagamentoViewModel entrada, IContasReceberData contasReceberData)
{
if (entrada.contasReceber != null)
{
ContasReceber contasReceber = contasReceberData.Get(entrada.contasReceber.id);
if (entrada.pagamento.valor > contasReceber.valorRestante)
{
return(false);
}
}
return(true);
}
public static PagamentoViewModel ToPagamentoViewModel(Pagamento pagamento)
{
var pagamentoViewModel = new PagamentoViewModel()
{
PagamentoId = pagamento.PagamentoId,
AlunoId = pagamento.AlunoId,
DataPagamento = pagamento.DataPagamento,
MeioPagamento = pagamento.MeioPagamento,
Valor = pagamento.Valor,
PedidoId = pagamento.PedidoId,
Pedido = PedidoAdapter.ToPedidoViewModel(pagamento.Pedido)
};
return(pagamentoViewModel);
}
public override void ItemClick(IItem item)
{
try
{
if (item != null)
{
var agenda = (SchedulerDto)Model;
var model = agenda.Model;
if (model.GetType() == typeof(FatturaAcquistoDto))
{
var obj = (FatturaAcquistoDto)model;
var space = new FatturaAcquistoModel();
var viewModel = new FatturaAcquistoViewModel();
AddSpace(space, obj, viewModel);
}
else if (model.GetType() == typeof(FatturaVenditaDto))
{
var obj = (FatturaVenditaDto)model;
var space = new FatturaVenditaModel();
var viewModel = new FatturaVenditaViewModel();
AddSpace(space, obj, viewModel);
}
else if (model.GetType() == typeof(PagamentoDto))
{
var obj = (PagamentoDto)model;
var space = new PagamentoModel();
var viewModel = new PagamentoViewModel();
AddSpace(space, obj, viewModel);
}
}
}
catch (Exception ex)
{
UtilityError.Write(ex);
}
}
