public HttpResponseMessage AtualizarPlano(HttpRequestMessage request, int IdPano, bool TrocarPlanoMembro, int TipoPagamentoId, CartaoCreditoViewModel cartaoCreditoViewModel)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
var dtTrocaPlano = new DateTime();
var mensalidadeCriada = false;
var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
Membro membro = _membroRep.FindBy(m => m.Pessoa.Id == usuario.Pessoa.Id).FirstOrDefault();
var _cartao = _cartaoCreditoRep.FirstOrDefault(x => x.MembroId == membro.Id);
var dtVencimento = new DateTime();
var dataHoje = DateTime.Now;
var dataFimGratuidade = membro.DataFimPeriodoGratuito ?? membro.DtCriacao;
var tipoPagamento = (TipoMovimentacao)TipoPagamentoId;
if (tipoPagamento == TipoMovimentacao.Boleto)
{
membro.PlanoMensalidadeId = IdPano;
dtVencimento = dataHoje.AddDays(1);
}
else
{
membro.PlanoMensalidadeId = IdPano;
_cartao.TokenCartaoGerenciaNet = cartaoCreditoViewModel.TokenCartaoGerenciaNet;
dtVencimento = DateTime.Now;
_cartaoCreditoRep.Edit(_cartao);
}
_membroRep.Edit(membro);
_unitOfWork.Commit();
if (!TrocarPlanoMembro)
{
mensalidadeCriada = _pagamentoService.GerarMensalidadeMembro(usuario, membro, dtVencimento, tipoPagamento);
}
else
{
dtTrocaPlano = _pagamentoService.TrocaPlano(usuario, membro, dtVencimento, tipoPagamento);
mensalidadeCriada = true;
}
response = request.CreateResponse(HttpStatusCode.OK, new { criouMensalidade = mensalidadeCriada, dataTrocaPlano = dtTrocaPlano.ToString("dd/MM/yyyy") });
}
return response;
}));
}
public void SalvarItemPedido(ItemPedido itemPedidoSalvar)
{
Usuario usuario = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);
itemPedidoSalvar.UsuarioAlteracao = usuario;
itemPedidoSalvar.DtAlteracao = DateTime.Now;
_itemPedidoRep.Edit(itemPedidoSalvar);
_unitOfWork.Commit();
}
public void Salvar(Emails email)
{
Usuario usuario = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);
email.UsuarioAlteracao = usuario;
email.DtAlteracao = DateTime.Now;
_emailsRep.Edit(email);
_unitOfWork.Commit();
}
public int Salvar(Sms sms)
{
var usuario = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);
sms.UsuarioAlteracao = usuario;
sms.DtAlteracao = DateTime.Now;
_smsRep.Edit(sms);
_unitOfWork.Commit();
return(sms.Id);
}
public HttpResponseMessage AtualizarTokenSignalR(HttpRequestMessage request, UsuarioViewModel usuarioVm)
{
return(CreateHttpResponse(request, () =>
{
var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
usuario.TokenSignalR = usuarioVm.TokenSignalRUser;
usuario.Logado = true;
usuario.DtUsuarioEntrou = DateTime.Now;
usuario.DtUsuarioSaiu = null;
usuario.OrigemLogin = usuarioVm.OrigemLogin;
_usuarioRep.Edit(usuario);
_unitOfWork.Commit();
var response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
return response;
}));
}
public HttpResponseMessage InserirMembroCategoria(HttpRequestMessage request, int membroId, int[] listCategoria)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
var usuario = _usuarioRep.GetSingle(1);
Membro _membro = _membroRep.GetSingle(membroId);
var membroCategorias =
_membeoCategoriaRep.GetAll().Where(x => x.MembroId == membroId);
if (membroCategorias.Any())
{
_membeoCategoriaRep.DeleteAll(membroCategorias);
}
foreach (var item in listCategoria)
{
MembroCategoria membroCategoria = new MembroCategoria()
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
MembroId = membroId,
CategoriaId = item,
Ativo = true
};
_membro.MembroCategorias.Add(membroCategoria);
}
_membroRep.Edit(_membro);
_unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
}
return response;
}));
}
public HttpResponseMessage SalvaTrocaItemFornecedor(HttpRequestMessage request, List <TrocaItemFornecedorViewModel> itensTroca)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
foreach (var item in itensTroca)
{
var itemToChange = _itemPedidoRep.GetSingle(item.ItemId);
itemToChange.Observacao = item.Observacao;
itemToChange.FornecedorId = item.FornecedorId;
itemToChange.PrecoNegociadoUnit = item.ValorItemFornecedor;
itemToChange.UsuarioAlteracaoId = usuario.Id;
_itemPedidoRep.Edit(itemToChange);
_unitOfWork.Commit();
}
response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
return response;
}));
}
public void CancelarPlanoAssinatura()
{
var dataHoje = DateTime.Now.Date;
var usuariosCancelados = _usuarioCanceladoRep.FindBy(x => x.DataCancelamento < dataHoje && x.Ativo).ToList();
var pessoa = new List <int>();
usuariosCancelados.ForEach(x =>
{
var usuario = _usuarioRep.FirstOrDefault(u => u.Id == x.UsuarioId);
usuario.Ativo = false;
_usuarioRep.Edit(usuario);
var usuarioCancelado = _usuarioCanceladoRep.FirstOrDefault(c => c.UsuarioId == x.UsuarioId);
usuarioCancelado.Ativo = false;
_usuarioCanceladoRep.Edit(usuarioCancelado);
_unitOfWork.Commit();
if (!pessoa.Contains(usuario.PessoaId))
{
pessoa.Add(usuario.PessoaId);
}
});
if (pessoa.Count > 0)
{
pessoa.ForEach(p =>
{
var membro = _membroRep.FirstOrDefault(m => m.PessoaId == p);
if (membro != null)
{
membro.Ativo = false;
_membroRep.Edit(membro);
}
var fornecedor = _forneceRep.FirstOrDefault(m => m.PessoaId == p);
if (fornecedor != null)
{
fornecedor.Ativo = false;
_forneceRep.Edit(fornecedor);
}
_unitOfWork.Commit();
});
}
}
public HttpResponseMessage ItensPedidoDespachado(HttpRequestMessage request, List <ItemPedidoViewModel> itenspedidoVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
var fornecedor = _fornecedorRep.FirstOrDefault(x => x.PessoaId == usuario.PessoaId);
var idPedido = itenspedidoVm?.FirstOrDefault().PedidoId;
var pedido = _pedidoRep.FirstOrDefault(x => x.Id == idPedido);
//Pegamos os ítens de pedidos que foram aprovados.
var itensPedido = pedido.ItemPedidos
.Where(x => x.AprovacaoFornecedor && x.Ativo && x.FornecedorId == fornecedor.Id).ToList();
foreach (var item in itensPedido)
{
item.UsuarioAlteracao = usuario;
item.DataEntregaFornecedor = DateTime.Now;
item.FlgDespacho = true;
_itemPedidoRep.Edit(item);
}
_ultilService.EnviaEmailPedido(pedido.Id, 6, usuario);
//pega o telefone do usuário q criou o pedido
var usuariosMembro = pedido.UsuarioCriacao;
Sms sms = new Sms()
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
Numero = usuariosMembro.Telefones.Select(t => t.DddCel).FirstOrDefault() + usuariosMembro.Telefones.Select(t => t.Celular).FirstOrDefault(),
Mensagem = "Economiza Já-Fornecedor Despachou para Entrega itens do seu pedido " + pedido.Id,
Status = StatusSms.NaoEnviado,
OrigemSms = TipoOrigemSms.FornecedorDespachoItensPedido,
Ativo = true
};
_smsRep.Add(sms);
_unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.OK, new { success = true, pedidoId = pedido.Id });
return response;
}));
}
public HttpResponseMessage ListaComprasRemove(HttpRequestMessage request, int listaId)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var listaCompras = _listaComprasRep.GetSingle(listaId);
listaCompras.Ativo = false;
_listaComprasRep.Edit(listaCompras);
_unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.OK);
return response;
}));
}
public HttpResponseMessage InserirCategoriaSegmento(HttpRequestMessage request, int categoriaId, int[] listSegmento)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
//Fornecedor _forencedor = _fornecedorRep.GetSingle(fornecedorId);
Categoria _categoria = _categoriaRep.GetSingle(categoriaId);
var categoriaSegmentos =
_segmentoCategoriaRep.GetAll().Where(x => x.CategoriaId == categoriaId);
if (categoriaSegmentos.Any())
{
_segmentoCategoriaRep.DeleteAll(categoriaSegmentos);
}
foreach (var item in listSegmento)
{
SegmentoCategoria SegmentoCategoria = new SegmentoCategoria()
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
SegmentoId = item,
CategoriaId = categoriaId,
Ativo = true
};
_categoria.SegmentosCategoria.Add(SegmentoCategoria);
}
_categoriaRep.Edit(_categoria);
_unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
}
return response;
}));
}
public List <KeyValuePair <int, Usuario> > AntecipacaoPedidoMembro()
{
var listPedUsuario = new List <KeyValuePair <int, Usuario> >();
var pedidos = _pedidoRep.FindBy(x => x.StatusSistemaId == 21 && (x.DtCotacao.Date - DateTime.Now.Date).Days == 2).ToList();
if (pedidos.Count > 0)
{
pedidos.ForEach(x =>
{
x.DtCotacao = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, x.DtCotacao.Hour, x.DtCotacao.Minute, DateTime.Now.Second);
_pedidoRep.Edit(x);
_unitOfWork.Commit();
var pedUsuario = new KeyValuePair <int, Usuario>(x.Id, x.UsuarioCriacao);
listPedUsuario.Add(pedUsuario);
});
}
return(listPedUsuario);
}
public HttpResponseMessage ConfirmaSms(HttpRequestMessage request, string phone, string smscenter, string text)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var idMsg = text.Split('@');
var sms = _smsRep.GetSingle(idMsg[1].TryParseInt());
sms.DataConfirmacaoEnvio = DateTime.Now;
_smsRep.Edit(sms);
_unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
return response;
}));
}
public void AtualizarCotacao(Cotacao cotacao)
{
//Atualiza Cotação
Usuario usuario = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);
cotacao.UsuarioAlteracao = usuario;
cotacao.DtAlteracao = DateTime.Now;
_cotacaoRep.Edit(cotacao);
//Limpa Avisos para fornecedores pendentes dessa cotação
var listaAviso = this._avisosRep.GetAll().Where(x => x.IdReferencia == cotacao.Id && x.TipoAvisosId == (int)TipoAviso.NovaCotacao);
foreach (var aviso in listaAviso)
{
this._avisosRep.Delete(aviso);
}
//commit
_unitOfWork.Commit();
}
public HttpResponseMessage GerarBoletoFornecedor(HttpRequestMessage request, FaturaViewModel faturaVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
var fatura = _faturaRep.GetSingle(faturaVm.Id);
var param = new List <string> {
"MULTA_MORA", "MULTA_ATRASO"
};
//Pega parâmetros de multa
var parametrosAtrasoPagtoFatura = _parametroSistemaRep.GetAll().Where(x => param.Contains(x.Codigo)).ToList();
var multaDiaria = (decimal)parametrosAtrasoPagtoFatura.FirstOrDefault(c => c.Codigo == "MULTA_MORA")?.Valor.TryParseInt() / 30;
var multaAtraso = parametrosAtrasoPagtoFatura.FirstOrDefault(c => c.Codigo == "MULTA_ATRASO")?.Valor.TryParseInt();
var pessoa = fatura.Fornecedor.Pessoa;
var telefone = pessoa.Telefones.FirstOrDefault(x => x.Ativo);
var endereco = pessoa.Enderecos.FirstOrDefault();
//endereco.Bairro = new Bairro();
//endereco.Estado = new Estado();
var diasAtraso = DateTime.Now.Subtract(fatura.DtVencimento).Days;
var valorAtrasoDias = fatura.Comissoes.Sum(x => x.Valor) * (diasAtraso * multaDiaria);
var valorMultaAtraso = fatura.Comissoes.Sum(x => x.Valor) * multaAtraso / 100;
var valorMulta = valorMultaAtraso + valorAtrasoDias;
var gerenciaNet = new GerencianetAPI();
#region Criando Transação
List <Item> itens = new List <Item>();
fatura.Comissoes.ForEach(c => itens.Add(new Item
{
Name = $"Pedido: {c.PedidoId}",
Value = (int)Convert.ToDecimal(string.Format("{0:N}", c.Valor).Replace(",", "").Replace(".", ""))
}));
itens.Add(new Item
{
Name = "Multa e Juros",
Value = (int)Convert.ToDecimal(string.Format("{0:N}", valorMulta).Replace(",", "").Replace(".", ""))
});
var metadata = new Metadata
{
CustomId = fatura.Id.ToString(),
NotificationURL = $"{ConfigurationManager.AppSettings[$"{Environment.GetEnvironmentVariable("Amb_EconomizaJa")}_UrlRetorno"]}api/pagamentos/retornoFatura"
};
var transacao = new TransactionRequest
{
Items = itens.ToArray(),
Metadata = metadata
};
var retornoTransacao = gerenciaNet.CreateTransaction(transacao);
#endregion
#region Associando Forma de Pagamento Boleto para Transação
Payment payment = new Payment();
payment.BankingBillet = new BankingBillet
{
ExpireAt = DateTime.Now.AddDays(1).ToShortDateString(), //Vencimento para o dia seguinte
Customer = new Customer
{
Name = pessoa.Usuarios.FirstOrDefault()?.UsuarioNome,
Birth = (pessoa.PessoaJuridica.DtFundacao ?? DateTime.Now).ToString("yyyy-MM-dd"),
Email = pessoa.PessoaJuridica.Email,
PhoneNumber = $"{telefone?.DddTelComl}{telefone?.TelefoneComl}",
Address = new Address
{
ZipCode = endereco.Cep,
City = endereco.Cidade.DescCidade,
Number = endereco.Numero.ToString(),
Neighborhood = endereco.Bairro.DescBairro,
Complement = endereco.Complemento,
State = endereco.Estado.Uf,
Street = endereco.DescEndereco
},
JuridicalPerson = new JuridicalPerson
{
CNPJ = pessoa.PessoaJuridica.Cnpj,
CorporateName = pessoa.PessoaJuridica.RazaoSocial
}
},
//Adicionando juros por dia caso venha pagar depois do vencimento
Configurations = new ConfigGerenciaNet
{
Interest = 33
},
Message = "Após vencimento será cobrado multa de 2% sobre o valor boleto e 0,033% ao dia."
};
var retornoBoleto = gerenciaNet.CreateBankingBillet(retornoTransacao.ChargerId, payment);
#endregion
#region Cancelando Boleto Vencido
var retornoCancelBoleto = new object();
if (fatura.ChargerId > 0)
{
retornoCancelBoleto = gerenciaNet.CancelTransaction(fatura.ChargerId);
}
#endregion
#region Atualizando Dados Fatura Banco
if (retornoCancelBoleto.TryParseInt() == 200)
{
fatura.DtAlteracao = DateTime.Now;
fatura.ChargerId = retornoBoleto.ChargeId;
fatura.UrlBoleto = retornoBoleto.Link;
fatura.Status = StatusFatura.AguardandoPagamento;
_faturaRep.Edit(fatura);
_unitOfWork.Commit();
#region Envia Email
Emails emails = new Emails
{
UsuarioCriacaoId = 1,
DtCriacao = DateTime.Now,
AssuntoEmail = "Boleto Gerado - 2º via do boleto gerada.",
EmailDestinatario = pessoa.PessoaJuridica.Email,
CorpoEmail = _templateRep.GetSingle(28).Template.Trim()
.Replace("#NomeFantasia#", pessoa.PessoaJuridica.NomeFantasia)
.Replace("#UrlBoleto#", fatura.UrlBoleto),
Status = Status.NaoEnviado,
Origem = Origem.BoletoGerado,
Ativo = true
};
_emailsRep.Add(emails);
_unitOfWork.Commit();
#endregion
}
#endregion
response = request.CreateResponse(HttpStatusCode.OK, new { });
return response;
}
return response;
}));
}
public HttpResponseMessage CancelarAssinatura(HttpRequestMessage request)
{
return(CreateHttpResponse(request, () =>
{
if (!ModelState.IsValid)
{
var response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
return response;
}
else
{
HttpResponseMessage response;
var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
var fornecedor = _fornecedorRep.FirstOrDefault(x => x.PessoaId == usuario.PessoaId);
var membro = _membroRep.FirstOrDefault(x => x.PessoaId == usuario.PessoaId);
if (fornecedor != null)
{
// Atualizar usuário como inativo caso não se tenha fatura em aberto
// No Client deve-se verificar se voltou faturas, se sim mostrar pop'up falando que assinatura
// só será cancelada quando se quitar as dívidas, direcionando usuário para tela de faturas para o mesmo imprimir o boleto.
// Quando se pagar a dívida, na notificação enviada pela GerenciaNet deve-se verificar
// a tabela de usuário cancelado e mudar o campo ativo do usuário e membro para false.
var usuarioCanceladoFornecedor = _usuarioCanceladoRep.FirstOrDefault(u => u.Usuario.PessoaId == fornecedor.PessoaId) != null;
if (usuario.FlgMaster)
{
if (!usuarioCanceladoFornecedor)
{
var faturas = _faturaRep
.GetAll().Where(x => x.FornecedorId == fornecedor.Id &&
(x.Status != StatusFatura.Recebido && x.Status != StatusFatura.Link &&
x.Status != StatusFatura.Cancelado && x.Status != StatusFatura.Devolvido)).ToList();
if (faturas.Count == 0)
{
var _usuariosDesativados = _usuarioRep.GetAll().Where(x => x.PessoaId == usuario.PessoaId).ToList();
for (int i = 0; i < _usuariosDesativados.Count; i++)
{
_usuariosDesativados[i].Ativo = false;
_usuarioRep.Edit(_usuariosDesativados[i]);
}
fornecedor.Ativo = false;
_fornecedorRep.Edit(fornecedor);
_usuarioCanceladoRep.Add(new UsuarioCancelado
{
UsuarioId = usuario.Id,
DataCancelamento = DateTime.Now,
UsuarioCriacaoId = usuario.Id,
DtCriacao = DateTime.Now,
Ativo = true
});
_unitOfWork.Commit();
var faturasVM = Mapper.Map <IEnumerable <Fatura>, IEnumerable <FaturaViewModel> >(faturas);
response = request.CreateResponse(HttpStatusCode.OK, faturasVM);
return response;
}
else
{
var faturasVM = Mapper.Map <IEnumerable <Fatura>, IEnumerable <FaturaViewModel> >(faturas);
response = request.CreateResponse(HttpStatusCode.OK, faturasVM);
return response;
}
}
}
else
{
var usuarioMaster = _usuarioRep.FirstOrDefault(x => x.PessoaId == usuario.PessoaId && !x.FlgMaster);
response = request.CreateResponse(HttpStatusCode.OK, "Somente o usuário " + usuarioMaster.UsuarioNome + " pode cancelar a assinatura, pois o mesmo é usuário Master!");
return response;
}
}
else if (membro != null)
{
// Inserir na tabela de usuário cancelado para se ter histórico de cancelamento, caso
// membro esteja em dia e esteja no mês corrente mostrar mensagem no client que a assinatura estara ativa até o dia anterior ao fechar a mensalidade para próximo mês.
// Colocar data na mensagem do client Ex: (sua assinatura estara ativa até o dia tal, somente para consultar de pedidos)
//colocar data de desabilitação para robô passar e mudar usuário para inativo
// na data estipulada no campo desta tabela.
// No Client deve-se verificar se voltou mensalidades, se sim mostrar pop'up falando que assinatura
// só será cancelada quando se quitar as dívidas, direcionando usuário para tela de mensalidades para o mesmo imprimir o boleto.
// Quando se pagar a dívida, na notificação enviada pela GerenciaNet deve-se verificar
// a tabela de usuário cancelado e mudar o campo ativo do usuário e membro para false.
var usuarioCanceladoMembro = _usuarioCanceladoRep.FirstOrDefault(u => u.Usuario.PessoaId == membro.PessoaId) != null;
if (!usuarioCanceladoMembro)
{
if (usuario.FlgMaster)
{
var mens = _mensalidadeRep.FindBy(x => x.Membro.PessoaId == usuario.PessoaId &&
x.Status == StatusMensalidade.Recebido ||
x.Status == StatusMensalidade.AguardandoPagamento)
.OrderByDescending(x => x.Id)
.FirstOrDefault();
if (mens != null && mens.Status == StatusMensalidade.Recebido)
{
// Cancelar Plano
_pagamentoService.CancelarPlano(mens.Id);
var dataFimAcesso = mens.DtRecebimento != null ?
mens.DtRecebimento.Value.AddMonths(membro.PlanoMensalidade.QtdMeses) : DateTime.Now;
var _usuariosDesativados = _usuarioRep.FindBy(x => x.PessoaId == usuario.PessoaId).ToList();
if (dataFimAcesso < DateTime.Now)
{
for (int i = 0; i < _usuariosDesativados.Count; i++)
{
_usuariosDesativados[i].Ativo = false;
_usuarioRep.Edit(_usuariosDesativados[i]);
}
membro.Ativo = false;
_membroRep.Edit(membro);
}
_usuarioCanceladoRep.Add(new UsuarioCancelado
{
UsuarioId = usuario.Id,
DataCancelamento = dataFimAcesso,
UsuarioCriacaoId = usuario.Id,
DtCriacao = DateTime.Now,
Ativo = true
});
mens.Ativo = false;
_mensalidadeRep.Edit(mens);
_unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.OK,
$"Você ainda terá até o dia {dataFimAcesso.ToShortDateString()} para acessar a plataforma, depois deste prazo sua conta será desativada automaticamente.");
return response;
}
else
{
if (!usuarioCanceladoMembro)
{
// Cancelar plano
if (mens != null)
{
_pagamentoService.CancelarPlano(mens.Id);
}
var _usuariosDesativados = _usuarioRep.FindBy(x => x.PessoaId == usuario.PessoaId).ToList();
for (int i = 0; i < _usuariosDesativados.Count; i++)
{
_usuariosDesativados[i].Ativo = false;
_usuarioRep.Edit(_usuariosDesativados[i]);
}
membro.Ativo = false;
_membroRep.Edit(membro);
_usuarioCanceladoRep.Add(new UsuarioCancelado
{
UsuarioId = usuario.Id,
DataCancelamento = DateTime.Now,
UsuarioCriacaoId = usuario.Id,
DtCriacao = DateTime.Now,
Ativo = true
});
_unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.Created, "Assinatura cancelada com sucesso!");
return response;
}
}
}
else
{
var usuarioMaster = _usuarioRep.FirstOrDefault(x => x.PessoaId == usuario.PessoaId && x.FlgMaster);
response = request.CreateResponse(HttpStatusCode.OK, "Somente o usuário ''" + usuarioMaster.UsuarioNome + "'' poderá cancelar a assinatura, pois o mesmo é usuário Master!");
return response;
}
}
}
response = request.CreateResponse(HttpStatusCode.NoContent);
return response;
}
}));
}
public void CancelarPedidoMembro()
{
var usuarioSistema = _usuarioRep.FirstOrDefault(x => x.Id == 1);
var diasParametroFechamentoPedido = Convert.ToInt64(_parametroSistemaRep.FindBy(x => x.Codigo.Equals("FECHAMENTO_PEDIDO")).FirstOrDefault().Valor);
var pedidos = _pedidoRep.FindBy(x => x.StatusSistemaId == 23).ToList();
if (pedidos.Count > 0)
{
pedidos.ForEach(x =>
{
var nomeMembro = x.Membro.Pessoa.TipoPessoa == TipoPessoa.PessoaJuridica ? x.Membro.Pessoa.PessoaJuridica.NomeFantasia
: x.Membro.Pessoa.PessoaFisica.Nome;
var diasAguardandoAprovacao = (DateTime.Now - x.DtAlteracao.Value).Days;
var templateEmail = _templateEmailRep.GetSingle(44).Template
.Replace("#NomeMembro#", nomeMembro)
.Replace("#Id#", x.Id.ToString())
.Replace("#DiasCancelamento#", diasParametroFechamentoPedido.ToString());
if (diasAguardandoAprovacao >= diasParametroFechamentoPedido)
{
x.StatusSistemaId = 36; //Status do Pedido Cancelado
_pedidoRep.Edit(x);
var pedidoHistorico = new HistStatusPedido
{
UsuarioCriacaoId = usuarioSistema.Id,
UsuarioCriacao = usuarioSistema,
DtCriacao = DateTime.Now,
PedidoId = x.Id,
StatusSistemaId = 36, //Status do Pedido Cancelado
DescMotivoCancelamento = $"Cancelamento efetuado pelo sistema, pois passou o prazo de {diasParametroFechamentoPedido} dias para aprovação.",
Ativo = true,
};
_histStatusPedidoRep.Add(pedidoHistorico);
Emails emails = new Emails
{
UsuarioCriacao = usuarioSistema,
DtCriacao = DateTime.Now,
AssuntoEmail = $"Pedido {x.Id} cancelado por falta de aprovação.",
//pega o email do usuario q criou o pedido para notifica-lo entidade UsuarioCriacao
EmailDestinatario = x.UsuarioCriacao.UsuarioEmail,
CorpoEmail = templateEmail.Trim(),
Status = Status.NaoEnviado,
Origem = Origem.CancelamentoPedidoNaoAprovadoPeloMembro,
Ativo = true
};
_emailRep.Add(emails);
//pega o celular do usuario q criou o pedido, se caso no futuro uma empresa tiver mais de um usuario
// manda para o usuario q criou o pedido
var Cel = x.UsuarioCriacao.Telefones.Select(c => new { celular = c.DddCel + c.Celular }).FirstOrDefault();
Sms sms = new Sms
{
UsuarioCriacao = usuarioSistema,
DtCriacao = DateTime.Now,
Numero = Cel.celular.ToString(),
Mensagem = $"Pedido {x.Id} cancelado por falta de aprovação.",
Status = StatusSms.NaoEnviado,
OrigemSms = TipoOrigemSms.CancelamentoPedidoNaoAprovadoPeloMembro,
Ativo = true
};
_smsRep.Add(sms);
_unitOfWork.Commit();
}
});
}
}
public HttpResponseMessage InserirCartaoCredito(HttpRequestMessage request, CartaoCreditoViewModel cartaoCreditoViewModel)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var cartao = new CartaoCredito();
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
var membro = this._membroRep.GetAll().FirstOrDefault(x => x.PessoaId.Equals(usuario.PessoaId));
if (cartaoCreditoViewModel.Padrao)
{
var _param = new[]
{
new SqlParameter {
ParameterName = "@PADRAO", SqlDbType = System.Data.SqlDbType.Bit, Value = 0
},
new SqlParameter {
ParameterName = "@PADRAO1", SqlDbType = System.Data.SqlDbType.Bit, Value = 1
}
};
var sql = "UPDATE CartaoCredito set Padrao = @PADRAO WHERE Padrao = @PADRAO1";
_cartaoCreditoRep.ExecuteWithStoreProcedure(sql, _param);
_unitOfWork.Commit();
}
if (cartaoCreditoViewModel.Id != null && cartaoCreditoViewModel.Id > 0)
{
cartao = _cartaoCreditoRep.FirstOrDefault(x => x.Id == cartaoCreditoViewModel.Id);
cartao.Nome = cartaoCreditoViewModel.Nome;
cartao.Numero = cartaoCreditoViewModel.Numero;
cartao.DataVencimento = Convert.ToDateTime(cartaoCreditoViewModel.DataVencimento);
cartao.Cvc = $"{usuario.Chave}|{_encryptionService.EncryptCvv(cartaoCreditoViewModel.Cvc)}";
cartao.TokenCartaoGerenciaNet = string.Empty;
cartao.CartaoBandeiraId = cartaoCreditoViewModel.CartaoBandeiraId;
cartao.Padrao = cartaoCreditoViewModel.Padrao;
cartao.MembroId = membro.Id;
cartao.Ativo = true;
cartao.UsuarioAlteracaoId = usuario.Id;
cartao.UsuarioAlteracao = usuario;
cartao.DtAlteracao = DateTime.Now;
_cartaoCreditoRep.Edit(cartao);
_unitOfWork.Commit();
}
else
{
cartao = new CartaoCredito
{
Nome = cartaoCreditoViewModel.Nome,
Numero = cartaoCreditoViewModel.Numero,
DataVencimento = Convert.ToDateTime(cartaoCreditoViewModel.DataVencimento),
CartaoBandeiraId = cartaoCreditoViewModel.CartaoBandeiraId,
Cvc = $"{usuario.Chave}|{_encryptionService.EncryptCvv(cartaoCreditoViewModel.Cvc)}",
TokenCartaoGerenciaNet = string.Empty,
Padrao = true,
MembroId = membro.Id,
Ativo = true,
UsuarioCriacaoId = usuario.Id,
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
};
_cartaoCreditoRep.Add(cartao);
_unitOfWork.Commit();
cartaoCreditoViewModel.Id = cartao.Id;
}
response = request.CreateResponse(HttpStatusCode.Created, cartaoCreditoViewModel);
}
return response;
}));
}
public HttpResponseMessage RetornoMensalidade(HttpRequestMessage request, TokenNotificationGerenciaNet retorno)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var status = new int();
var data = _pagamentoService.ReturnStatusFatura(retorno.Notification);
switch (data.Status.StatusAtual)
{
case "new":
status = (int)StatusMensalidade.Gerado; // Assinatura criada, porém nenhuma cobrança foi paga. O termo "new" equivale a "nova".
break;
case "active":
status = (int)StatusMensalidade.Recebido; // Assinatura ativa. Todas as cobranças estão sendo geradas. O termo "active" equivale a "ativa".
break;
case "paid":
status = (int)StatusMensalidade.Recebido;
break;
case "waiting":
status = (int)StatusMensalidade.AguardandoPagamento;
break;
case "canceled":
status = (int)StatusMensalidade.Cancelado; // Assinatura foi cancelada pelo vendedor ou pelo pagador. O termo "canceled" equivale a "cancelada".
break;
case "expired":
status = (int)StatusMensalidade.AssinaturaExpirada; // Assinatura expirada. Todas as cobranças configuradas para a assinatura já foram emitidas.
// O termo "expired" equivale a "expirada".
break;
case "unpaid":
status = (int)StatusMensalidade.NaoPago;
break;
case "settled":
status = (int)StatusMensalidade.Recebido;
break;
case "refunded":
status = (int)StatusMensalidade.Devolvido;
break;
case "contested":
status = (int)StatusMensalidade.Contestado;
break;
}
var mensalidade = _mensalidadeRep.GetSingle(data.CustomId);
if (status == (int)StatusMensalidade.Recebido)
{
mensalidade.DtRecebimento = DateTime.Now;
mensalidade.Status = (StatusMensalidade)status;
mensalidade.Token = retorno.Notification;
}
else if (mensalidade.Status != StatusMensalidade.Recebido)
{
mensalidade.Status = (StatusMensalidade)status;
mensalidade.Token = retorno.Notification;
}
_mensalidadeRep.Edit(mensalidade);
_unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.OK, new { });
return response;
}));
}
public HttpResponseMessage InserirPf(HttpRequestMessage request, MembroPFViewModel membroPFViewModel)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
if (_membroRep.CpfExistente(membroPFViewModel.Cpf) > 0)
{
ModelState.AddModelError("CPF Existente", "CPF:" + membroPFViewModel.Cpf + " já existe .");
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else if (_membroRep.CroExistente(membroPFViewModel.Cro) > 0)
{
ModelState.AddModelError("CRO Existente", "CRO:" + membroPFViewModel.Cro + " já existe .");
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
var usuario = _usuarioRep.GetSingle(1);
var pessoa = new Pessoa
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
TipoPessoa = TipoPessoa.PessoaFisica,
Ativo = membroPFViewModel.Ativo,
};
var pessoaFisica = new PessoaFisica
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
Pessoa = pessoa,
Nome = membroPFViewModel.Nome,
Cpf = membroPFViewModel.Cpf,
Rg = membroPFViewModel.Rg,
Cro = membroPFViewModel.Cro,
DtNascimento = membroPFViewModel.DtNascimento,
Email = membroPFViewModel.Email,
Sexo = (Sexo)membroPFViewModel.Sexo,
Ativo = membroPFViewModel.Ativo
};
_pessoaFisicaRep.Add(pessoaFisica);
_unitOfWork.Commit();
pessoa.PessoaFisica = pessoaFisica;
_pessoaRep.Edit(pessoa);
_unitOfWork.Commit();
var novoMembro = new Membro
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
Pessoa = pessoa,
Comprador = membroPFViewModel.Comprador,
Ativo = membroPFViewModel.Ativo,
Vip = membroPFViewModel.Vip,
DddTel = membroPFViewModel.DddTelComl,
Telefone = membroPFViewModel.TelefoneComl,
DddCel = membroPFViewModel.DddCel,
Celular = membroPFViewModel.Celular,
Contato = membroPFViewModel.Contato,
DataFimPeriodoGratuito = DateTime.Now.AddDays(30)
};
_membroRep.Add(novoMembro);
_unitOfWork.Commit();
var email = new Emails
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
AssuntoEmail = "Novo Membro Cliente PF",
EmailDestinatario = "*****@*****.**",
CorpoEmail = "NOVO CLIENTE",
Status = Status.NaoEnviado,
Origem = 0,
Ativo = true
};
_emailsRep.Add(email);
_unitOfWork.Commit();
// Update view model
membroPFViewModel = Mapper.Map <Membro, MembroPFViewModel>(novoMembro);
response = request.CreateResponse(HttpStatusCode.Created, membroPFViewModel);
}
}
return response;
}));
}
public HttpResponseMessage SalvaTrocaMembroItemFornecedor(HttpRequestMessage request, TrocaItemFornecedorViewModel itemTroca)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
var itemToChange = _itemPedidoRep.GetSingle(itemTroca.ItemId);
var _pedido = _pedidoRep.GetSingle(itemToChange.PedidoId);
//Verifca se o fornecedor escolhido ainda nao aprovou os itens que o mesmo ganhou
var existePedParaAprovar = _pedido.ItemPedidos.Any(x => x.FornecedorId == itemTroca.FornecedorId && !x.AprovacaoFornecedor && x.Ativo);
if (existePedParaAprovar)
{
var formaPagtoIdFornecedorChosen = _pedido.ItemPedidos.Where(x => x.FornecedorId == itemTroca.FornecedorId).Select(x => x.FormaPagtoId).FirstOrDefault();
itemToChange.Observacao = itemTroca.Observacao;
itemToChange.FornecedorId = itemTroca.FornecedorId;
itemToChange.PrecoNegociadoUnit = itemTroca.ValorItemFornecedor;
itemToChange.UsuarioAlteracaoId = usuario.Id;
itemToChange.FormaPagtoId = formaPagtoIdFornecedorChosen;
itemToChange.AprovacaoFornecedor = false;
itemToChange.Ativo = true;
_itemPedidoRep.Edit(itemToChange);
_unitOfWork.Commit();
_utilServiceRep.EnviaEmailSmsNovoPedidoItemfornecedor(_pedido.Id, itemTroca.ItemId, usuario, existePedParaAprovar);
}
else
{
if (itemTroca.FornecedorPagtoIdChosen == 0)
{
ModelState.AddModelError("FormaPagto de Pagamento", "Selecione uma forma de pagamento para o fornecedor selecionado");
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
return response;
}
else
{
var formaPagtoIdFornecedorChosen = _pedido.ItemPedidos.Where(x => x.FornecedorId == itemTroca.FornecedorId).Select(x => x.FormaPagtoId).FirstOrDefault();
itemToChange.Observacao = itemTroca.Observacao;
itemToChange.FornecedorId = itemTroca.FornecedorId;
itemToChange.PrecoNegociadoUnit = itemTroca.ValorItemFornecedor;
itemToChange.UsuarioAlteracaoId = usuario.Id;
itemToChange.FormaPagtoId = formaPagtoIdFornecedorChosen != null && formaPagtoIdFornecedorChosen > 0 ? formaPagtoIdFornecedorChosen : itemTroca.FornecedorPagtoIdChosen;
itemToChange.AprovacaoFornecedor = false;
itemToChange.Ativo = true;
_itemPedidoRep.Edit(itemToChange);
_unitOfWork.Commit();
_utilServiceRep.EnviaEmailSmsNovoPedidoItemfornecedor(_pedido.Id, itemTroca.ItemId, usuario, existePedParaAprovar);
}
}
if (_pedido.StatusSistemaId == 36 || _pedido.StatusSistemaId == 29)
{
_pedido.StatusSistemaId = 24;
_pedidoRep.Edit(_pedido);
_unitOfWork.Commit();
}
response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
return response;
}));
}