protected void btnLiberarPgto_Click(object sender, EventArgs e)
{
try
{
Pagamento pgto = new Pagamento();
PagamentoBLL obj = new PagamentoBLL();
pgto.Id_regiao = Convert.ToInt32(ddlRegiao.SelectedValue);
pgto.Id_cooperativa = Convert.ToInt32(ddlCooperativa.SelectedValue);
pgto.Id_propriedade = Convert.ToInt32(ddlPropriedade.SelectedValue);
pgto.Dt_inicio = txtDataInicial.Text;
pgto.Dt_fim = txtDataFinal.Text;
if (txtDataInicial.Text == string.Empty || txtDataFinal.Text == string.Empty)
throw new Exception("Preencha a data inicial e a data final");
if (pgto.Id_propriedade == 0)
throw new Exception("Selecione apenas uma propriedade!");
string login = Convert.ToString(Session["LOGIN"]);
bool existePgto = obj.LiberarPagamento(pgto, login);
if (existePgto == true)
{
ClientScript.RegisterStartupScript(this.GetType(), "alert", "<script>alert('Pagamentos liberados!');</script>");
}
}
catch (Exception ex)
{
ClientScript.RegisterStartupScript(this.GetType(), "alert", "<script>alert('" + ex.Message.ToString() + "');</script>");
}
}
protected void Page_Load(object sender, EventArgs e)
{
this.Page.Title = "Pgto de Produtores - Relatório de Pagamentos de Produtor";
try
{
Pagamento pgto = new Pagamento();
PagamentoBLL obj = new PagamentoBLL();
String strPathreport = String.Empty;
pgto.Id_regiao = Convert.ToInt32(Session["ID_REGIAO"]);
pgto.Id_cooperativa = Convert.ToInt32(Session["ID_COOPERATIVA"]);
pgto.Id_propriedade = Convert.ToInt32(Session["ID_PROPRIEDADE"]);
pgto.Dt_inicio = Convert.ToString(Session["DT_INICIO"]);
pgto.Dt_fim = Convert.ToString(Session["DT_FIM"]);
pgto.Tp_relatorio = Convert.ToChar(Session["TP_RELATORIO"]);
strPathreport = Server.MapPath("Relatorio.rpt");
CrystalReportViewer1.LogOnInfo = Crystal.ConectaCrystal();
CrystalReportViewer1.ReportSource = obj.GerarRelatorioPgtoProdutores(pgto, strPathreport);
CrystalReportViewer1.DataBind();
}
catch (Exception ex)
{
ClientScript.RegisterStartupScript(this.GetType(), "alert", "<script>alert('" + ex.Message.ToString() + "');</script>");
}
}
public bool LiberarPagamento(Pagamento pgto, String usuario)
{
// Verifica se há pagamento para os produtores
DataSet ds = new DataSet();
ds = ListarColetas(pgto);
//Se houver pagamento, libera o pagamento e grava o log
if (ds != null && ds.Tables[0].Rows.Count > 0)
{
try
{
LiberarPagto(pgto);
GravarLogExportacao(usuario);
return true;
}
catch (SqlException ex)
{
throw new Exception("Erro no servidor nro." + ex.Number);
//return false;
}
}
else
{
throw new Exception("Não há pagamentos para o produtor selecionado!");
//return false;
}
}
public ActionResult Edit([Bind(Include = "Fornecimento,Valor,DataEmissao")] Pagamento pagamento)
{
if (ModelState.IsValid)
{
db.Entry(pagamento).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Fornecimento = new SelectList(db.FornecimentoMaterial, "ID", "ID", pagamento.Fornecimento);
return(View(pagamento));
}
public IActionResult DeletePagamento(string idPagamento, string idContasReceber)
{
Pagamento modelo = new Pagamento();
modelo.id = new Guid(idPagamento);
pagamentoData.Delete(modelo);
ContasReceberRules.CalculoPagamento(new Guid(idContasReceber), pagamentoData, contasReceberData);
return(RedirectToAction("GridPagamento", "Pagamento", new { idContasReceber = idContasReceber }));
}
public ActionResult GerarParcelasPagamento(int clienteId)
{
Cliente cliente = db.Clientes.Find(clienteId);
Grupos grupo = db.Grupos.Find(cliente.Grupo_id);
if (cliente.pagamentoGerado == 0)
{
int parcelas = cliente.Grupos.Nu_parcelas;
var pagamento = new Pagamento();
var olddate = DateTime.Now;
DateTime?isVencimento = null;
isVencimento = grupo.Dt_Vencimento;
int i = 0;
while (parcelas > 0)
{
pagamento.Clienteid = cliente.ClienteId;
pagamento.Grupo_id = cliente.Grupo_id;
pagamento.Representacao_id = cliente.Representacao_id;
pagamento.Status_Pagamento = "NÃO PAGO";
i++;
if (i >= 0)
{
var tempDate = isVencimento.Value.AddMonths(i);
DateTime dataAtual = DateTime.Today;
var newDate = new DateTime(dataAtual.Year, tempDate.Month, tempDate.Day); //create
pagamento.Dt_Vencimento = newDate;
}
pagamento.Valor_Pago = cliente.Valor_Credito * 1 / 100;
pagamento.Parcela_num = i;
parcelas = parcelas - 1;
db.Pagamentos.Add(pagamento);
db.SaveChanges();
}
cliente.pagamentoGerado = 1;
db.SaveChanges();
}
var resultado = new
{
Sucess = true
};
return(Json(resultado, JsonRequestBehavior.AllowGet));
}
private async Task ValidaPagamento(Pagamento pagamento)
{
if (pagamento == null)
{
throw new ArgumentNullException(nameof(pagamento));
}
await VerificaClienteExiste(pagamento.ClienteId);
await VerificaAssinaturaExiste(pagamento.AssinaturaId);
}
public void EstornarPagamento()
{
if (Pagamento.IsEmpty)
{
AddDomainError("Esse título ainda não foi pago.");
}
else
{
Pagamento = new Pagamento();
}
}
public void Pagar(Pagamento pagamento)
{
if (!Pagamento.IsEmpty)
{
AddDomainError("O pagamento desse título já foi efetuado.");
}
else
{
Pagamento = new Pagamento(pagamento.DataPagamento, pagamento.ValorPago);
}
}
public Retorno DarBaixaPagamento(Pagamento pagamento)
{
try
{
return(new BusinessPagamento().Salvar(pagamento));
}
catch (Exception ex)
{
return(Retorno.CriarRetornoExcecao(ex));
}
}
public Pagamento CalcularTroco(decimal valorVenda, decimal valorPago)
{
Pagamento pagamento = new Pagamento(valorVenda, valorPago);
if (!pagamento.ValorPagoEhValido())
{
throw new PagamentoBusinessException("Não foi possível realizar a transação. O valor pago é menor que o valor da venda.");
}
return(pagamento);
}
public Duplicata(string numeroDocumento, DateTime dataEmissao, DateTime dataVencimento, Fornecedor fornecedor, decimal valor, string notaFiscalId, string observacao)
{
NumeroDocumento = numeroDocumento;
DataEmissao = dataEmissao;
DataVencimento = dataVencimento;
Fornecedor = fornecedor;
Valor = valor;
NotaFiscalId = notaFiscalId;
Observacao = observacao ?? Observacao;
Pagamento = new Pagamento();
}
public FrmCadFornecedor(int codigo)
{
InitializeComponent();
produto = new Produto();
produto.fornecedor.Codigo = codigo;
if (codigo > 0)
{
//ao abrir o Form, é preparado para ações de alteração de registro
if (produto.fornecedor.PegaNome() == 1)
{
txtNome.Text = produto.fornecedor.Nome;
Text = "Editar Fornecedor - Vismo";
lblTitulo.Text = "Editar fornecedor";
btnSalvar.Visible = false;
btnEditar.Visible = true;
if (produto.fornecedor.Status == "Desabilitado")
{
lblStatus.Text = "Habilitar fornecedor";
}
lblStatus.Visible = true;
lblRemover.Visible = true;
//checa se fornecedor está relacionado com algum produto ou pagamento no sistema
if (produto.Busca() == 0)
{
Pagamento pagamento = new Pagamento();
pagamento.fornecedor.Codigo = produto.fornecedor.Codigo;
if (pagamento.Busca() == 0)
{
//se não estiver, é possivel remover o fornecedor do sistema
lblRemover.Enabled = true;
}
}
}
else
{
MessageBox.Show("Ocorreu um erro ao procurar pelo registro.", "Erro",
MessageBoxButtons.OK, MessageBoxIcon.Error);
//fecha o Form caso ocorra algum erro ao carregar as informações do fornecedor
Close();
}
}
}
public ActionResult EditarPagamento(int codigo, int pagamento, string data, int mes, int ano, string valor)
{
Funcionario funcionario = Funcionario.ObterPorCodigo(codigo);
Pagamento temp = funcionario.Pagamento.FirstOrDefault(p => p.CodPagamento == pagamento);
temp.DtPagamento = DateTime.Parse(data);
temp.MesReferencia = mes;
temp.AnoReferencia = ano;
temp.Valor = Decimal.Parse(valor, new CultureInfo("pt-BR"));
Contexto.Current.SaveChanges();
return(PartialView("_Pagamentos", funcionario.Pagamento.Where(p => p.AnoReferencia == ano && p.MesReferencia == mes).ToList()));
}
public void Update(Pagamento modelo)
{
db.Attach(modelo);
db.Entry(modelo).Property("valor").IsModified = true;
db.Entry(modelo).Property("dataPagamento").IsModified = true;
db.Entry(modelo).Property("tipoPagamento").IsModified = true;
db.Entry(modelo).Property("modificadoPor").IsModified = true;
db.Entry(modelo).Property("modificadoPorName").IsModified = true;
db.Entry(modelo).Property("modificadoEm").IsModified = true;
db.SaveChanges();
}
public void TotalValor(Aluguel aluguel)
{
TimeSpan duracao = aluguel.Final.Subtract(aluguel.Inicial);
double valor = Itax.Valor(PrecoHora, PrecoDia, duracao);
double taxa = Itax.Tax(valor);
Pagamento pagamento = new Pagamento(valor, taxa);
Console.WriteLine(pagamento.Imprimir());
}
public async Task <IActionResult> Create([Bind("Id,DataVencimento,Quantidade,ValorParcela,PedidoId")] Pagamento pagamento)
{
if (ModelState.IsValid)
{
_context.Add(pagamento);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["PedidoId"] = new SelectList(_context.Pedido, "Id", "Id", pagamento.PedidoId);
return(View(pagamento));
}
public void Pagar(decimal valor)
{
valorPago = valor;
if (valor == valorBoleto)
{
situacaoPagamento = Pagamento.Pago;
}
else
{
situacaoPagamento = Pagamento.PagoParcial;
}
}
private void GerarPagtoCmd_Execute(object obj)
{
NotaFiscal.Pagamentos = NotaFiscal.Pagamentos ?? new ObservableCollection <PagamentoVO>();
Pagamento.ValidateModel();
if (!Pagamento.HasErrors)
{
NotaFiscal.Pagamentos.Add(Pagamento);
Pagamento = new PagamentoVO();
}
}
public bool Publicar([FromBody] dynamic param)
{
Entities context = new Entities();
Banner obj = new Banner();
Plano plano = context.Plano.Find(Convert.ToInt32(param.IdPlano));
Cliente cliente = context.Cliente.Find(AppExtension.IdUsuarioLogado());
if (AppExtension.ToDateTime(param.Estreia) < DateTime.Today)
{
throw new Exception("Você não pode publicar um banner retroativo.");
}
if (Convert.ToInt32(param.IdTipoAcao) == 0)
{
obj.Link = param.Link.ToString();
obj.Telefone = null;
}
else
{
obj.Link = null;
obj.Telefone = param.Telefone.ToString();
}
obj.IdCliente = cliente.Id;
obj.Descricao = param.Descricao.ToString();
obj.Titulo = param.Titulo.ToString();
obj.Estreia = Convert.ToDateTime(param.Estreia?.ToString() + " " + param.EstreiaHorario?.ToString());
obj.Expiracao = obj.Estreia.AddDays(plano.Dias);
obj.Situacao = param.Situacao.ToString();
obj.Cadastro = DateTime.Now;
obj.Imagem = FileController.SaveFile(param.Imagem?.ToString(), ".jpg");
Pagamento pagamento = new Pagamento();
pagamento.Cliente = cliente;
pagamento.Plano = plano;
pagamento.Situacao = 0;
pagamento.Valor = plano.Valor;
pagamento.CheckoutIdentifier = Guid.NewGuid().ToString();
pagamento.DataCriacao = DateTime.Now;
pagamento.Dias = plano.Dias;
pagamento.Descricao = plano.Descricao;
pagamento.Vezes = plano.Vezes;
pagamento.TipoPlano = plano.TipoPlano;
pagamento.BeneficioAplicado = "N";
obj.Pagamento.Add(pagamento);
context.Banner.Add(obj);
context.SaveChanges();
return(true);
}
double valorEmAberto = 0; // VARIÁVEL QUE SERÁ EDITADA PELA REGRA DE NEGÓCIO EM PAGAMENTO.CONTROLLER
// GET: Contrato
public ActionResult Adicionar(int idCliente, string nomeTitular, double valorContrato, int quantidadeParcelas, DateTime primeiroVencimento, string garantia, int empresaIdEmpresa)
{
Contrato contrato = new Contrato();
ContratoDAO dao = new ContratoDAO();
Cliente cliente = new Cliente();
contrato.IdCliente = idCliente;
contrato.NomeTitular = nomeTitular;
contrato.ValorContrato = valorContrato;
contrato.QuantidadeParcelas = quantidadeParcelas;
contrato.PrimeiroVencimento = primeiroVencimento;
contrato.Garantia = garantia;
contrato.EmpresaIdEmpresa = empresaIdEmpresa;
contrato.ValorEmAberto = valorEmAberto;
dao.Adicionar(contrato);
double auxiliarValorParcela = 0; // Usada para ALTERAR a entidade valorEmABerto na entidade CONTRATO depois
//que o método do método de valor de parcelas ter calculado o montante total
double valorParcela;
for (var i = 0; i < quantidadeParcelas; i++)
{
Pagamento pagamento = new Pagamento();
valorParcela = pagamento.CalculoContrato(valorContrato, quantidadeParcelas);
// INSERINDO NA TABELA PAGAMENTOS
PagamentoDAO daoPagamento = new PagamentoDAO();
pagamento.ValorIntegralDaParcela = valorParcela;
pagamento.Status = 0;
pagamento.IdContrato = contrato.IdContrato;
// ^ Metodo precisa vir depois de ADICIONAR CONTRATO, para que ele tenha uma ID pra ser registrada na table pagamentos
pagamento.IdCliente = idCliente;
// ^ Este dado não é pedido na entidade CONTRATO
pagamento.DataVencimento = primeiroVencimento.AddMonths(i);
daoPagamento.Adicionar(pagamento);
auxiliarValorParcela = valorParcela * quantidadeParcelas;
}
contrato.ValorEmAberto = auxiliarValorParcela;
dao.Alterar(contrato);
return(RedirectToAction("Form"));
}
public Duplicata(Guid id, string numeroDocumento, DateTime dataEmissao, DateTime dataVencimento, Fornecedor fornecedor, decimal valor, string observacao = null)
{
Id = id;
NumeroDocumento = numeroDocumento;
DataEmissao = dataEmissao;
DataVencimento = dataVencimento;
Fornecedor = fornecedor;
Valor = valor;
Observacao = observacao ?? Observacao;
Pagamento = new Pagamento();
}
public async Task <IActionResult> Create([Bind("IdPagto,IdCli,Cpf,Contrato,Parcela,Data,Valor,Desconto,Situacao")] Pagamento pagamento)
{
if (ModelState.IsValid)
{
_context.Add(pagamento);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["IdCli"] = new SelectList(_context.Cliente, "IdCli", "IdCli", pagamento.IdCli);
return(View(pagamento));
}
public ActionResult Create([Bind(Include = "Id,NumeroParcela,ValorParcela,Anotacao,Extra1,Extra2,Extra3,PedidoId")] Pagamento pagamento)
{
if (ModelState.IsValid)
{
db.Pagamentos.Add(pagamento);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.PedidoId = new SelectList(db.Pedidos, "Id", "DetalhePagamento", pagamento.PedidoId);
return(View(pagamento));
}
public async Task <IActionResult> Create([Bind("CodPagamento,IdtipoPagamento,NomeTitular,NumCartao,DataValidadeCartao,Cvv,Descricao")] Pagamento pagamento)
{
if (ModelState.IsValid)
{
_context.Add(pagamento);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["IdtipoPagamento"] = new SelectList(_context.TipoPagamento, "IdtipoPagamento", "Designacao", pagamento.IdtipoPagamento);
return(View(pagamento));
}
public bool RealizarPagamento(Pedido pedido, Pagamento pagamento)
{
var apiKey = _configManager.GetValue("apiKey");
var encriptionKey = _configManager.GetValue("encriptionKey");
var serviceKey = _payPalGateway.GetPayPalServiceKey(apiKey, encriptionKey);
var cardHashKey = _payPalGateway.GetCardHashKey(serviceKey, pagamento.CartaoCredito);
var pagamentoResult = _payPalGateway.CommitTransaction(cardHashKey, pedido.Id.ToString(), pagamento.Valor);
return(pagamentoResult);
}
public async Task <IActionResult> PostPagamento([FromBody] Pagamento pagamento)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Pagamento.Add(pagamento);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPagamento", new { id = pagamento.Id }, pagamento));
}
public void SetUp()
{
_produto = CriarProdutoLivro();
_itemDeCompra = CriarItemCompra();
_pagamentoCartao = CriarPagamentoCartao();
compra = FabricaCompra.Criar();
compra.AdicionarItem(_itemDeCompra);
compra.Fechar();
compra.InformarDadosPagamento(_pagamentoCartao);
compra.Pagar();
}
public IActionResult Post([FromBody] Pagamento pagamento)
{
try
{
_repo.Incluir(pagamento);
return(Ok(_repo.SelecionarTudo()));
}
catch (System.Exception)
{
return(StatusCode(500));
}
}
public IActionResult Put(int id, [FromBody] Pagamento pagamento)
{
try
{
_repo.Alterar(pagamento);
return(Ok(_repo.SelecionarTudo()));
}
catch (System.Exception)
{
return(StatusCode(500));
}
}
static void Main(string[] args)
{
Boleto boleto = new Boleto();
boleto.Desconto(10);
Cartao cartao = new Cartao();
cartao.Desconto(0);
Pagamento pagamento = new Pagamento();
}
public async Task <IActionResult> Create([Bind("Id_Pagamento,Bolsa_Id,Valor,MultaMora,JurosMora,DataVencimento,DataPagamento")] Pagamento pagamento)
{
if (ModelState.IsValid)
{
pagamento.Id_Pagamento = Guid.NewGuid();
_context.Add(pagamento);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(pagamento));
}
public void TestRelatorio()
{
Pagamento pgt = new Pagamento();
pgt.IdPessoa = 9;
var dataInicio = DateTime.Parse("2021-02-01");
var dataFim = DateTime.Parse("2021-02-11");
pgt.Observacao = "Pagamento referente ao mes de Março";
pgt.IdPagamento = 2;
var x = SvcPagamento.RelatorioPorPeriodo(dataInicio, dataFim);
}
public string excluirPagamento(Pagamento pagamento)
{
string erro = null;
try
{
pagamentos.DeleteObject(pagamento);
db.SaveChanges();
}
catch (Exception ex)
{
erro = ex.Message;
}
return erro;
}
public string adicionarPagamento(Pagamento pagamento)
{
string erro = null;
try
{
pagamentos.AddObject(pagamento);
db.SaveChanges();
}
catch (Exception ex)
{
erro = ex.Message;
}
return erro;
}
public ReportDocument GerarRelatorioPgtoProdutores(Pagamento pgto, String strPathreport)
{
SqlConnection cn = new SqlConnection(Conexao.SQL);
DataSet ds = new DataSet();
CrystalReportSource crpt = new CrystalReportSource();
ReportDocument rpt = new ReportDocument();
SqlCommand cmd = new SqlCommand("PR_REL_PGTO_PRODUTORES", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@ID_REGIAO", pgto.Id_regiao);
cmd.Parameters.AddWithValue("@ID_COOPERATIVA", pgto.Id_cooperativa);
cmd.Parameters.AddWithValue("@ID_PROPRIED", pgto.Id_propriedade);
cmd.Parameters.AddWithValue("@DT_INICIO", pgto.Dt_inicio);
cmd.Parameters.AddWithValue("@DT_FIM", pgto.Dt_fim);
cmd.Parameters.AddWithValue("@TP_RELATORIO", pgto.Tp_relatorio);
try
{
cn.Open();
SqlDataAdapter da = new SqlDataAdapter(cmd);
da.Fill(ds);
if (ds != null && ds.Tables[0].Rows.Count > 0)
{
DataTable dataTable = ds.Tables[0];
rpt.Load(strPathreport);
rpt.SetDataSource(dataTable);
}
else
{
throw new Exception("Não há coleta cadastrada para o período informado!");
}
}
catch (SqlException ex)
{
throw new Exception("Erro no servidor nro." + ex.Number);
}
finally
{
cn.Close();
}
return rpt;
}
public string editarPagamento(Pagamento pagamento)
{
string erro = null;
try
{
if (pagamento.EntityState == System.Data.EntityState.Detached)
{
pagamentos.Attach(pagamento);
}
db.ObjectStateManager.ChangeObjectState(pagamento, System.Data.EntityState.Modified);
db.SaveChanges();
}
catch (Exception ex)
{
erro = ex.Message;
}
return erro;
}
public ReportDocument GerarRelatorioPgtoProdutores(Pagamento pgto, String strPathreport)
{
PagamentoDAO obj = new PagamentoDAO();
ReportDocument rpt = new ReportDocument();
DateTime dtInicialDigitada = Convert.ToDateTime(pgto.Dt_inicio);
DateTime dtFinalDigitada = Convert.ToDateTime(pgto.Dt_fim);
String dataInicialDigitada = dtInicialDigitada.ToString("dd/MM/yyyy");
String dataFinalDigitada = dtFinalDigitada.ToString("dd/MM/yyyy");
if (pgto.Id_regiao == 0)
throw new Exception("Selecione a região!");
else if (pgto.Id_cooperativa == 0)
throw new Exception("Selecione a cooperativa!");
else if (Convert.ToDateTime(dataInicialDigitada) > Convert.ToDateTime(dataFinalDigitada))
throw new Exception("A data final não pode ser inferior a data inicial");
rpt = obj.GerarRelatorioPgtoProdutores(pgto, strPathreport);
return rpt;
}
public void ConsultaChequeTest()
{
using (ICupomFiscal cf = new ECF.CupomFiscal())
{
cf.AbreCupom(string.Empty, string.Empty, string.Empty);
cf.VendeItem("00001", "Caneta preta", "I", 5M, 1.50M, 0, "UN", "%", "D", 1);
cf.SubTotalizaCupom(0, string.Empty);
IList<IImpressoraFormaPagto> formas = new ImpressoraFormaPagto().Find<IImpressoraFormaPagto>(new Where {
{"cad_FormaPagto.TipoForma = @p1", new Parameter {
ParameterName = "@p1",
GenericDbType = GenericDbType.Integer,
Value = (int)TipoForma.Cheque
}}
});
IImpressoraFormaPagto forma = formas[0];
IPagamento cheque = new Pagamento(cf);
cheque.Pagar(forma, cf.SubTotal);
cf.FechaCupom(string.Empty);
}
}
private DataSet ListarColetas(Pagamento pgto)
{
SqlConnection cn = new SqlConnection(Conexao.SQL);
DataSet ds = new DataSet();
SqlCommand cmd = new SqlCommand("PR_REL_PGTO_PRODUTORES", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@ID_REGIAO", pgto.Id_regiao);
cmd.Parameters.AddWithValue("@ID_COOPERATIVA", pgto.Id_cooperativa);
cmd.Parameters.AddWithValue("@ID_PROPRIED", pgto.Id_propriedade);
cmd.Parameters.AddWithValue("@DT_INICIO", pgto.Dt_inicio);
cmd.Parameters.AddWithValue("@DT_FIM", pgto.Dt_fim);
cmd.Parameters.AddWithValue("@TP_RELATORIO", "A");
try
{
cn.Open();
SqlDataAdapter da = new SqlDataAdapter(cmd);
da.Fill(ds);
}
catch (SqlException ex)
{
throw new Exception("Erro no servidor nro." + ex.Number);
}
finally
{
cn.Close();
}
return ds;
}
public JsonResult PagarBoleto(int idCobranca, decimal valorPagar, int formaPag_Value)
{
string mensagem;
Pagamento p = new Pagamento();
p.idCobranca = idCobranca;
p.valor = valorPagar;
p.formaPag = formaPag_Value;
p.dataPagamento = DateTime.Now;
try
{
dbPagamento.Adicionar(p);
dbPagamento.SaveChanges();
var cob = dbCobranca.FindOne(x => x.idCobranca == idCobranca);
var juros = DateTime.Now > cob.dataVencimento ? (DateTime.Now.Day - cob.dataVencimento.Day) * (cob.valorTotal * 0.02m) : 0;
cob.juros = juros;
cob.statusPagamento = (int)EnumStatus.Pago;
dbCobranca.Atualizar(cob);
dbCobranca.SaveChanges();
mensagem = "Pagamento realizado com sucesso!";
return Json(new { success = true, message = mensagem });
}
catch (Exception e)
{
mensagem = "Erro: " + e.Message;
return Json(new { success = false, message = mensagem });
}
}
public VendaFacade()
{
entrega = new Entrega();
ordemPedido = new OrdemPedido();
pagamento = new Pagamento();
}
public void UpdatePagamento(Pagamento pagamento)
{
model.Entry(pagamento).State = EntityState.Modified;
model.SaveChanges();
}
private void LiberarPagto(Pagamento pgto)
{
SqlConnection cn = new SqlConnection(Conexao.SQL);
SqlCommand cmd = new SqlCommand("PR_INTEG_PAGTO_PROPRIED", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@REGIAO", pgto.Id_regiao);
cmd.Parameters.AddWithValue("@COOPERATIVA", pgto.Id_cooperativa);
cmd.Parameters.AddWithValue("@PROPRIEDADE", pgto.Id_propriedade);
cmd.Parameters.AddWithValue("@DTINI", pgto.Dt_inicio);
cmd.Parameters.AddWithValue("@DTFIM", pgto.Dt_fim);
try
{
cn.Open();
cmd.ExecuteNonQuery();
}
catch (SqlException ex)
{
throw new Exception("Erro no servidor nro." + ex.Number);
}
finally
{
cn.Close();
}
}
public bool LiberarPagamento(Pagamento pgto, String usuario)
{
PagamentoDAO obj = new PagamentoDAO();
return obj.LiberarPagamento(pgto, usuario);
}
public PagarNotaFiscalResposta PagarNotaFiscal(PagarNotaFiscalRequisicao requisicao)
{
var nota = _notaFiscalRepositorio.ObterPor(requisicao.CodigoDaNota);
var dataUpload = SystemTime.Now;
var pagamento = new Pagamento
{
Comprovante = new Arquivo(requisicao.DescricaoDoComprovante, requisicao.NomeDoComprovante, dataUpload),
Observacao = requisicao.Observacao,
DataPagamento = requisicao.DataPagamento
};
_repositorioDeArquivos.ArmazenarArquivo(requisicao.Comprovante, requisicao.NomeDoComprovante, dataUpload);
nota.Pagar(pagamento);
_unitOfWork.Commit();
return new PagarNotaFiscalResposta() { Sucesso = true };
}
public void PagamentoCartaoTest()
{
using(ICupomFiscal cf = new ECF.CupomFiscal())
{
cf.FechaCupom(string.Empty);
cf.AbreCupom(string.Empty, string.Empty, string.Empty);
cf.VendeItem("00001", "Caneta azul", "F", 10M, 1.50M, 0, "UN", "%", "D", 1);
cf.SubTotalizaCupom(0, string.Empty);
IList<IImpressoraFormaPagto> formas = new ImpressoraFormaPagto().Find<IImpressoraFormaPagto>(new Where {
{"cad_FormaPagto.TipoForma = @p1", new Parameter {
ParameterName = "@p1",
GenericDbType = GenericDbType.Integer,
Value = (int)TipoForma.CartaoCredito
}}
});
IImpressoraFormaPagto forma = formas[0];
IPagamento pag = new Pagamento(cf);
pag.Pagar(forma, 15.00M, cf.COO.ToString());
if(cf.Estado == ACBrFramework.ECF.EstadoECF.Pagamento &&
cf.TotalPago == cf.SubTotal)
cf.FechaCupom("Obrigado. Volte sempre!");
pag.ImprimirTransacoesPendentes();
pag.Confirmacao();
}
using (ICupomFiscal c = new ECF.CupomFiscal())
{
}
}
