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 HttpResponseMessage Get(HttpRequestMessage request, int?page, int?pageSize, string filter = null)
{
int currentPage = page.Value;
int currentPageSize = pageSize.Value;
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
List <Usuario> usuarioAdm = null;
int totalUsuarioAdm = new int();
if (!string.IsNullOrEmpty(filter))
{
filter = filter.Trim().ToLower();
usuarioAdm = _usuarioRep.FindBy(c => c.UsuarioNome.ToLower().Contains(filter) && c.PerfilId == 1)
.OrderBy(c => c.UsuarioNome)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalUsuarioAdm = _usuarioRep
.GetAll().Where(c => c.PerfilId == 1)
.Count(c => c.UsuarioNome.ToLower().Contains(filter));
}
else
{
usuarioAdm = _usuarioRep.GetAll().Where(c => c.PerfilId == 1)
.OrderBy(c => c.UsuarioNome)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalUsuarioAdm = _usuarioRep.GetAll().Count(c => c.PerfilId == 1);
}
IEnumerable <UsuarioViewModel> usuarioVM = Mapper.Map <IEnumerable <Usuario>, IEnumerable <UsuarioViewModel> >(usuarioAdm);
PaginacaoConfig <UsuarioViewModel> pagSet = new PaginacaoConfig <UsuarioViewModel>()
{
Page = currentPage,
TotalCount = totalUsuarioAdm,
TotalPages = (int)Math.Ceiling((decimal)totalUsuarioAdm / currentPageSize),
Items = usuarioVM
};
response = request.CreateResponse(HttpStatusCode.OK, pagSet);
return response;
}));
}
public HttpResponseMessage Get(HttpRequestMessage request, int?page, int?pageSize, string filter = null)
{
int currentPage = page.Value;
int currentPageSize = pageSize.Value;
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
List <UnidadeMedida> unidadeMedidas = null;
int totalUnidadeMedida = new int();
if (!string.IsNullOrEmpty(filter))
{
filter = filter.Trim().ToLower();
unidadeMedidas = _unidadeMedidaRep.FindBy(c => c.DescUnidadeMedida.ToLower().Contains(filter))
.OrderBy(c => c.DescUnidadeMedida)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalUnidadeMedida = _unidadeMedidaRep
.GetAll()
.Count(c => c.DescUnidadeMedida.ToLower().Contains(filter));
}
else
{
unidadeMedidas = _unidadeMedidaRep.GetAll()
.OrderBy(c => c.DescUnidadeMedida)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalUnidadeMedida = _unidadeMedidaRep.GetAll().Count();
}
IEnumerable <UnidadeMedidaViewModel> unidadeMedidasVM = Mapper.Map <IEnumerable <UnidadeMedida>, IEnumerable <UnidadeMedidaViewModel> >(unidadeMedidas);
PaginacaoConfig <UnidadeMedidaViewModel> pagSet = new PaginacaoConfig <UnidadeMedidaViewModel>()
{
Page = currentPage,
TotalCount = totalUnidadeMedida,
TotalPages = (int)Math.Ceiling((decimal)totalUnidadeMedida / currentPageSize),
Items = unidadeMedidasVM
};
response = request.CreateResponse(HttpStatusCode.OK, pagSet);
return response;
}));
}
public StatusSistema BuscaStatusSistema(int pWorkflowStatusId, int pOrdem)
{
StatusSistema retStatusSis;
retStatusSis = _statusSistemaRep.FindBy(ss => ss.WorkflowStatusId == pWorkflowStatusId && ss.Ordem == pOrdem).FirstOrDefault();
return(retStatusSis);
}
public HttpResponseMessage GetMembro(HttpRequestMessage request)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
Membro membro = _membroRep.FindBy(m => m.PessoaId == usuario.Pessoa.Id).FirstOrDefault();
MembroViewModel estoqueVM = Mapper.Map <Membro, MembroViewModel>(membro);
response = request.CreateResponse(HttpStatusCode.OK, estoqueVM);
return response;
}));
}
public HttpResponseMessage CancelarPlanoMembro(HttpRequestMessage request, int?mensalidadeId)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response;
bool cancelouPlano = false;
var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
Membro membro = _membroRep.FindBy(m => m.Pessoa.Id == usuario.Pessoa.Id).FirstOrDefault();
if (mensalidadeId != null && mensalidadeId.Value > 0)
{
cancelouPlano = _pagamentoService.CancelarPlano(mensalidadeId.Value);
}
if (mensalidadeId.Value == 0)
{
var mensalidade = _mensalidadeRep.FindBy(x => x.MembroId == membro.Id && x.Status == StatusMensalidade.Recebido)
.OrderByDescending(o => o.Id).FirstOrDefault();
cancelouPlano = _pagamentoService.CancelarPlano(mensalidade.Id);
}
response = request.CreateResponse(HttpStatusCode.OK, cancelouPlano);
return response;
}));
}
public HttpResponseMessage GetPlanosMensalidade(HttpRequestMessage request)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
var membro = _membroRep.All.FirstOrDefault(x => x.PessoaId == usuario.PessoaId);
var segmentoMembroId = membro.MembroCategorias.SelectMany(x => x.Categoria.SegmentosCategoria).FirstOrDefault().SegmentoId;
var listaPlanosMensalidadesId = _planoSegmentoRep.FindBy(x => x.SegmentoId == segmentoMembroId && x.Ativo).Select(x => x.PlanoMensalidadeId).ToList();
var planosMensalidade = _planosMensalidadeRep.FindBy(x => listaPlanosMensalidadesId.Contains(x.Id) && x.Ativo).ToList();
var planoMensalidadeVM = new List <PlanoMensalidadeViewModel>();
planosMensalidade.ForEach(x =>
{
planoMensalidadeVM.Add(new PlanoMensalidadeViewModel
{
Id = x.Id,
Descricao = x.Descricao,
QtdMeses = x.QtdMeses,
Valor = x.Valor,
Ativo = x.Ativo
});
});
response = request.CreateResponse(HttpStatusCode.OK, planoMensalidadeVM);
return response;
}));
}
public List <Fornecedor> ListaFornecedoresPorMembro(int MembroID)
{
List <Fornecedor> retFornecedor = new List <Fornecedor>();
var mfor = _membroFornecedorRep.FindBy(mf => mf.MembroId == MembroID);
retFornecedor = mfor.Select(mf => mf.Fornecedor).ToList();
return(retFornecedor);
}
/// <summary>
/// Remove os avisos do Fornecedor referente a Cotação.
/// </summary>
/// <param name="pessoaId">Passar o ID da Pessoa</param>
/// <param name="cotacaoId">Passar o ID da Cotação</param>
/// <param name="tipoAviso">Passar o ID de tipo do Aviso, pode estar no Enum TipoAviso ou senão terá que acessar o banco para saber o ID necessário</param>
public void RemoverAvisoUsuarioFornecedorCotacao(int pessoaId, int cotacaoId, int tipoAviso)
{
var usuarios = _usuarioRep.FindBy(u => u.PessoaId == pessoaId).ToList();
foreach (var usuario in usuarios)
{
var aviso = this._avisosRep.FirstOrDefault(x => x.UsuarioNotificadoId == usuario.Id && x.IdReferencia == cotacaoId && x.TipoAvisosId == tipoAviso);
if (aviso == null)
{
continue;
}
this._avisosRep.Delete(aviso);
}
this._unitOfWork.Commit();
}
public Fornecedor BuscaFornecedorById(int FornedecorId)
{
Fornecedor retFornecedor = new Fornecedor();
var fornec = _FornecedorRep.FindBy(f => f.Id == FornedecorId);
retFornecedor = fornec.FirstOrDefault();
return(retFornecedor);
}
public HttpResponseMessage GetCartaoCredito(HttpRequestMessage request, int cartaoId)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var cartao = new List <CartaoCredito>();
var cartaoCreditoVM = new List <CartaoCreditoViewModel>();
var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
var membro = this._membroRep.GetAll().FirstOrDefault(x => x.PessoaId.Equals(usuario.PessoaId));
if (cartaoId > 0)
{
cartao = _cartaoCreditoRep.FindBy(x => x.Id == cartaoId && x.MembroId == membro.Id && x.Ativo).ToList();
}
else
{
cartao = _cartaoCreditoRep.FindBy(x => x.MembroId == membro.Id && x.Ativo).ToList();
}
cartao.ForEach(x =>
{
cartaoCreditoVM.Add(new CartaoCreditoViewModel
{
Id = x.Id,
Nome = x.Nome,
Numero = x.Numero,
DataVencimento = x.DataVencimento.ToString("MM/yyyy"),
DescricaoCartaoBandeira = x.CartaoBandeira.Descricao,
//Cvv = x.Cvv,
Padrao = x.Padrao,
Ativo = x.Ativo
});
});
response = request.CreateResponse(HttpStatusCode.OK, cartaoCreditoVM);
return response;
}));
}
public HttpResponseMessage GetSubCategoriaPaginacao(HttpRequestMessage request, int?page, int?pageSize, string filter = null)
{
int currentPage = page.Value;
int currentPageSize = pageSize.Value;
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
List <SubCategoria> subCategorias = null;
int totalSubCategorias = new int();
if (!string.IsNullOrEmpty(filter))
{
filter = filter.Trim().ToLower();
subCategorias = _subCategoriaRep.FindBy(c => c.DescSubCategoria.ToLower().Contains(filter) ||
c.Ativo.ToString() == filter || c.Categoria.DescCategoria.ToLower().Contains(filter) || c.Id.ToString() == filter)
.OrderBy(c => c.Categoria.DescCategoria)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalSubCategorias = _subCategoriaRep
.GetAll()
.Count(c => c.DescSubCategoria.ToLower().Contains(filter));
}
else
{
subCategorias = _subCategoriaRep.GetAll()
.OrderBy(c => c.DescSubCategoria)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalSubCategorias = _subCategoriaRep.GetAll().Count();
}
IEnumerable <SubCategoriaViewModel> subCategoriasVM = Mapper.Map <IEnumerable <SubCategoria>, IEnumerable <SubCategoriaViewModel> >(subCategorias);
PaginacaoConfig <SubCategoriaViewModel> pagSet = new PaginacaoConfig <SubCategoriaViewModel>()
{
Page = currentPage,
TotalCount = totalSubCategorias,
TotalPages = (int)Math.Ceiling((decimal)totalSubCategorias / currentPageSize),
Items = subCategoriasVM
};
response = request.CreateResponse(HttpStatusCode.OK, pagSet);
return response;
}));
}
public HttpResponseMessage Get(HttpRequestMessage request, int?page, int?pageSize, string filter = null)
{
int currentPage = page.Value;
int currentPageSize = pageSize.Value;
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
List <Fabricante> fabricante = null;
int totalFabricante = new int();
if (!string.IsNullOrEmpty(filter))
{
filter = filter.Trim().ToLower();
fabricante = _Fabricante.FindBy(c => c.DescFabricante.ToLower().Contains(filter))
.OrderBy(c => c.DescFabricante)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalFabricante = _Fabricante
.GetAll()
.Count(c => c.DescFabricante.ToLower().Contains(filter));
}
else
{
fabricante = _Fabricante.GetAll()
.OrderBy(c => c.DescFabricante)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalFabricante = _Fabricante.GetAll().Count();
}
IEnumerable <FabricanteViewModel> fabricanteVM = Mapper.Map <IEnumerable <Fabricante>, IEnumerable <FabricanteViewModel> >(fabricante);
PaginacaoConfig <FabricanteViewModel> pagSet = new PaginacaoConfig <FabricanteViewModel>()
{
Page = currentPage,
TotalCount = totalFabricante,
TotalPages = (int)Math.Ceiling((decimal)totalFabricante / currentPageSize),
Items = fabricanteVM
};
response = request.CreateResponse(HttpStatusCode.OK, pagSet);
return response;
}));
}
public HttpResponseMessage GetByCategoriaId(HttpRequestMessage request, int?page, int?pageSize, int membroId)
{
int currentPage = page.Value;
int currentPageSize = pageSize.Value;
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
List <MembroDemanda> demandas = null;
int totalMembros = new int();
if (membroId != 0)
{
demandas = _membroDemandaRep.FindBy(c => c.MembroId.Equals(membroId))
.OrderBy(c => c.SubCategoria.DescSubCategoria)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalMembros = _membroDemandaRep
.GetAll()
.Count(c => c.MembroId.Equals(membroId));
}
//else
//{
// demandas = _membroDemandaRep.GetAll()
// .OrderBy(c => c.SubCategoria.DescSubCategoria)
// .Skip(currentPage * currentPageSize)
// .Take(currentPageSize)
// .ToList();
// totalMembros = _membroRep.GetAll().Count();
//}
IEnumerable <MembroDemandaViewModel> membroDemandasVM = Mapper.Map <IEnumerable <MembroDemanda>, IEnumerable <MembroDemandaViewModel> >(demandas);
var pagSet = new PaginacaoConfig <MembroDemandaViewModel>()
{
Page = currentPage,
TotalCount = totalMembros,
TotalPages = (int)Math.Ceiling((decimal)totalMembros / currentPageSize),
Items = membroDemandasVM
};
response = request.CreateResponse(HttpStatusCode.OK, pagSet);
return response;
}));
}
public HttpResponseMessage GetCarregaRegiaoPrazo(HttpRequestMessage request, int?idFornecedor)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var cidades = new List <int>();
// var fornecedor = _fornecedorRep.FirstOrDefault(x => x.Id == idFornecedor);
var regiaoPrazoFornecedor = _fornecedorRegiaoRep.FindBy(x => x.Fornecedor.Id == idFornecedor).Select(x => new { x.Id, x.FornecedorId, x.CidadeId, x.Prazo, x.Cidade.DescCidade }).ToList();
//var regiaoPrazoFornecedorVM = fornecedor?.FornecedorRegiao
// .Where(x => x.VlPedMinRegiao != 0).Select(x => new { x.Id, x.FornecedorId, x.CidadeId, x.Prazo, x.Cidade.DescCidade } )
// .ToList();
var regiaoPrazoSemanalFornecedor = _fornecedorPrazoSemanalRep.FindBy(x => x.Fornecedor.Id == idFornecedor).Select(x => new { x.Id, x.FornecedorId, x.CidadeId, x.Cidade.DescCidade, x.DiaSemana, x.VlPedMinRegiao, x.TaxaEntrega, x.Cif }).ToList();
//var regiaoPrazoSemanalFornecedor = fornecedor?.FornecedorRegiaoSemanal
// .Where(x => x.VlPedMinRegiao != 0)
// .ToList();
//IEnumerable<FornecedorRegiaoViewModel> regiaoPrazoFornecedorVM = Mapper.Map<IEnumerable<FornecedorRegiao>, IEnumerable<FornecedorRegiaoViewModel>>(regiaoPrazoFornecedor);
// IEnumerable<FornecedorPrazoSemanalViewModel> fornecedorPrazoSemanalVM = Mapper.Map<IEnumerable<FornecedorPrazoSemanal>, IEnumerable<FornecedorPrazoSemanalViewModel>>(regiaoPrazoSemanalFornecedor);
var regiaoSemanalVM = regiaoPrazoSemanalFornecedor
.GroupBy(g => new { g.DescCidade, g.CidadeId })
.Select(g => new
{
NomeCidade = g.Key.DescCidade,
IdCidade = g.Key.CidadeId,
DiaSemana = g.Select(d => d.DiaSemana)
})
.ToList();
var listaCidadeCorridos = regiaoPrazoFornecedor.Select(c => c.CidadeId).ToList();
cidades.AddRange(listaCidadeCorridos);
var listaCidadesSemanal = regiaoSemanalVM.Select(c => c.IdCidade).ToList();
cidades.AddRange(listaCidadesSemanal);
var cidadesUnicas = cidades.Distinct();
var cidadesCorridosSemanal = _cidadeRep.GetAll().Where(c => cidadesUnicas.Contains(c.Id));
IEnumerable <CidadeViewModel> cidadesVM = Mapper.Map <IEnumerable <Cidade>, IEnumerable <CidadeViewModel> >(cidadesCorridosSemanal);
response = request.CreateResponse(HttpStatusCode.OK, new { regiaoPrazoFornecedor, regiaoSemanalVM, cidadesVM });
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 List <CotacaoPedidos> ListarCotacaoPedidos()
{
// Status pedido em cotacao
var statusId = _statusSistemaRep.GetAll().FirstOrDefault(x => x.WorkflowStatusId == 12 && x.Ordem == 2).Id;
DateTime dataConsulta = DateTime.Now;
List <CotacaoPedidos> listaCotacaoPedido = _cotacaoPedidoRep.FindBy(cpr => cpr.Ativo &&
cpr.Cotacao.DtFechamento < dataConsulta &&
cpr.Pedido.FlgCotado &&
cpr.Pedido.StatusSistemaId == statusId
).ToList();
return(listaCotacaoPedido);
}
public void EmailNotificacaoFornecedor(List <Usuario> fornecedores, int CotacaoId)
{
try
{
Usuario usuario = _usuarioRep.GetSingle(SessaoEconomiza.UsuarioId);
var corpoEmail = _templateEmail.FindBy(e => e.Id == 16).Select(e => e.Template).FirstOrDefault();
if (fornecedores.Count > 0)
{
if (corpoEmail != null)
{
foreach (var fornecedor in fornecedores)
{
string corpoEmailFornecedor = corpoEmail.Replace("#IDCotacao#", CotacaoId.ToString());
if (_notificacoesAlertasService.PodeEnviarNotificacao(fornecedor.Id, 16, TipoAlerta.EMAIL))
{
Emails emails = new Emails
{
Ativo = true,
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
AssuntoEmail = "Cotação - Você teve o melhor preco na cotação " + CotacaoId + "",
EmailDestinatario = fornecedor.UsuarioEmail,
CorpoEmail = corpoEmailFornecedor.Trim(),
Status = Status.NaoEnviado,
Origem = Origem.MembroSolicitaFornecedor
};
//Envia EMAIL para fornecedor
_emailsNotificaoRep.Add(emails);
//Commit
_unitOfWork.Commit();
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public HttpResponseMessage Atualizar(HttpRequestMessage request, CategoriaViewModel categoriaViewModel)
{
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
{
Categoria novaCategoria = _categoriaRep.GetSingle(categoriaViewModel.Id);
Usuario usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
var fornecedorCategoria = _fornecedorCategoriaRep.FindBy(x => x.CategoriaId == categoriaViewModel.Id).Count();
var membroCategoria = _membroCategoriaRep.FindBy(m => m.CategoriaId == categoriaViewModel.Id).Count();
if (fornecedorCategoria == 0 && membroCategoria == 0)
{
novaCategoria.AtualizarCategoria(categoriaViewModel, usuario);
_unitOfWork.Commit();
// Update view model
categoriaViewModel = Mapper.Map <Categoria, CategoriaViewModel>(novaCategoria);
response = request.CreateResponse(HttpStatusCode.OK, categoriaViewModel);
}
else
{
response = request.CreateResponse(HttpStatusCode.BadRequest, categoriaViewModel);
}
}
return response;
}));
}
public HttpResponseMessage GetEnderecoViaCep(HttpRequestMessage request, string filter = null)
{
return(CreateHttpResponse(request, () =>
{
var usuario = new Usuario();
var pessoaId = 0;
List <Endereco> listaEnderecos;
if (!string.IsNullOrEmpty(filter))
{
usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
filter = filter.Trim().ToLower();
listaEnderecos = _enderecoRep.FindBy(c => c.DescEndereco.ToLower().Contains(filter) ||
c.Cidade.DescCidade.ToLower().Contains(filter) ||
c.Complemento.ToLower().Contains(filter) ||
c.Cep.ToLower().Contains(filter) ||
c.Bairro.DescBairro.ToLower().Contains(filter) &&
c.PessoaId == usuario.PessoaId
).OrderByDescending(x => x.EnderecoPadrao).ThenByDescending(x => x.Ativo).ToList();
}
else
{
usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
listaEnderecos = _enderecoRep.GetAll().Where(x => x.Pessoa.Id == usuario.PessoaId).OrderByDescending(x => x.EnderecoPadrao).ThenByDescending(x => x.Ativo).ToList();
}
var enderecosVM = Mapper.Map <IEnumerable <Endereco>, IEnumerable <EnderecoViewModel> >(listaEnderecos);
var response = request.CreateResponse(HttpStatusCode.OK, enderecosVM);
return response;
}));
}
public HttpResponseMessage GetCartaoBandeira(HttpRequestMessage request)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var cartaoBandeiraVM = new List <CartaoBandeiraViewModel>();
var cartaoBandeira = _cartaoBandeiraRep.FindBy(x => x.Ativo).ToList();
cartaoBandeira.ForEach(x =>
{
cartaoBandeiraVM.Add(new CartaoBandeiraViewModel
{
Id = x.Id,
Descricao = x.Descricao,
Ativo = x.Ativo
});
});
response = request.CreateResponse(HttpStatusCode.OK, cartaoBandeiraVM);
return response;
}));
}
public List <Emails> BuscarPendentes(int limite)
{
return(_emailsRep.FindBy(x => x.Status == Status.Pendente).OrderBy(x => x.DtCriacao)
.Take(limite)
.ToList());
}
public List <RetornoAvisos> TrataNovaCotacaoFornecedor(Cotacao pCotacao, int TipoAvisosId)
{
var listaRetorno = new List <RetornoAvisos>();
var cotacaoesPedidos = _cotacaoPedidoRep.GetAll().Where(w => w.CotacaoId == pCotacao.Id).ToList();
//resgatar todos fornecedores que deram lance na cotação
var fornecedoresDeramLance = _resultadoCotacaoRep.FindBy(rc => rc.CotacaoId == pCotacao.Id).Select(s => s.Fornecedor).ToList();
//pegar todos fornecedores que podem dar o lance na cotação
var todosMembrosCotacao = cotacaoesPedidos.Select(s => s.Pedido.MembroId).ToList();
var todosFornecedores = _membroFornecedorRep.GetAll().Where(w => todosMembrosCotacao.Contains(w.MembroId)).Select(s => s.Fornecedor).ToList();
//fazer distinção dos fornecedores que deram o lance e que podiam dar o lance, para separar os que ainda não deram
var fornecedoresNaoDeramLance = todosFornecedores.Except(fornecedoresDeramLance).ToList();
//Pegar todos Usuarios dos fornecedores que não deram lance
var pFornecedores = fornecedoresNaoDeramLance.Select(s => s.Pessoa.Id).ToList();
var lUsu = _usuarioRep.GetAll().Where(u => pFornecedores.Contains(u.PessoaId)).ToList();
foreach (var usu in lUsu)
{
var retEnviarEmail = false;
var retEnviarSMS = false;
var retNovoAviso = false;
//Pega o Registro do Aviso para validar se necessário novo envio de email, caso não tiver deve ser criado um registro
var novoAviso = _avisosRep.GetAll().FirstOrDefault(av => av.TipoAvisosId == TipoAvisosId &&
av.UsuarioNotificadoId == usu.Id &&
av.IdReferencia == pCotacao.Id);
if (novoAviso == null)
{
retNovoAviso = true;
}
//Valida Se Necessário enviar email
if (PodeEnviarNotificacao(usu.Id, TipoAvisosId, TipoAlerta.EMAIL) && (!retNovoAviso && novoAviso.DataUltimoAviso.AddMinutes(30) < DateTime.Now))
{
retEnviarEmail = true;
}
//Valida se necessário enviar SMS
if (PodeEnviarNotificacao(usu.Id, TipoAvisosId, TipoAlerta.SMS) && (!retNovoAviso && novoAviso.DataUltimoAviso.AddMinutes(30) < DateTime.Now))
{
retEnviarSMS = true;
}
//Cria lista com dados para envio.
listaRetorno.Add(new RetornoAvisos
{
EnviarEmail = retEnviarEmail,
EnviarSMS = retEnviarSMS,
NovoAviso = retNovoAviso,
Usuario = usu,
Aviso = novoAviso
});
}
return(listaRetorno);
}
public List <Pedido> ListarPedidosPendentes(Enum pCliente)
{
bool CotacapoAceiteMembro = true;
// Status pedido em cotacao
int statusIdPend = 0;
int statusIdPendHist = 0;
if ((TipoCliente)pCliente == TipoCliente.Membro)
{
//Status pedido Aguardando Membro
statusIdPend = _statusSistemaRep.GetAll().FirstOrDefault(x => x.WorkflowStatusId == 12 && x.Ordem == 3).Id;
statusIdPendHist = statusIdPend;
}
else
{
//Status pedido Aguardando Fornecedor
statusIdPend = _statusSistemaRep.GetAll().FirstOrDefault(x => x.WorkflowStatusId == 12 && x.Ordem == 4).Id;
statusIdPendHist = _statusSistemaRep.GetAll().FirstOrDefault(x => x.WorkflowStatusId == 12 && x.Ordem == 3).Id;
}
List <Pedido> lPedidoPendente = _pedidoRep.FindBy(p => p.StatusSistemaId == statusIdPend).ToList();
List <Pedido> lPedidoIdPendenteAtrasado = new List <Pedido>();
Pedido pedidoAtrasado = null;
foreach (Pedido item in lPedidoPendente)
{
var objRet = _histStatusPedidoRep.GetAll().FirstOrDefault(hp => hp.PedidoId == item.Id &&
hp.StatusSistemaId == statusIdPendHist
);
if (objRet != null)
{
pedidoAtrasado = objRet.Pedido;
}
if (pedidoAtrasado != null)
{
CotacapoAceiteMembro = true;
if ((TipoCliente)pCliente == TipoCliente.Fornecedor)
{
//Verifica se Todos os pedidos da cotação foram aceitos pelo membro, para ai sim avisar o fornecedor.
CotacaoPedidos lcotPed = _cotacaoPedidoRep.GetAll().FirstOrDefault(lp => lp.PedidoId == item.Id);
List <CotacaoPedidos> lcot = _cotacaoPedidoRep.GetAll().Where(cpr => cpr.CotacaoId == lcotPed.CotacaoId).ToList();
foreach (CotacaoPedidos itemCot in lcot)
{
if (itemCot.Pedido.StatusSistemaId != statusIdPend)
{
CotacapoAceiteMembro = false;
}
}
}
if (CotacapoAceiteMembro)
{
lPedidoIdPendenteAtrasado.Add(pedidoAtrasado);
}
}
}
return(lPedidoIdPendenteAtrasado);
}
public List <Usuario> EnviarEmailSmsFornecedorAceitarMembro()
{
var usuarios = new List <Usuario>();
var membrosFornecedores = _membroFornecedorRep.FindBy(x => !x.Ativo).ToList();
membrosFornecedores.ForEach(x =>
{
var nomeMembro = string.Empty;
if (x.Membro.Pessoa.TipoPessoa == TipoPessoa.PessoaFisica)
{
nomeMembro = x.Membro.Pessoa.PessoaFisica.Nome;
}
else
{
nomeMembro = x.Membro.Pessoa.PessoaJuridica.NomeFantasia;
}
x.Fornecedor.Pessoa.Usuarios.ToList().ForEach(u =>
{
if (PodeEnviarNotificacao(u.Id, (int)TipoAviso.NovoFornecedorAvisoMembro, TipoAlerta.EMAIL))
{
Emails email1 = new Emails()
{
EmailDestinatario = u.UsuarioEmail,
CorpoEmail = this.GetCorpoEmail(36)
.Replace("#NomeFornecedor#", x.Fornecedor.Pessoa.PessoaJuridica.NomeFantasia)
.Replace("#Membro#", nomeMembro),
AssuntoEmail = "Solicitação de membro pendente de aceite",
Status = Status.NaoEnviado,
Origem = Origem.LembreteFornecedorAceiteMembro,
DtCriacao = DateTime.Now,
UsuarioCriacao = u,
Ativo = true
};
_emailsRep.Add(email1);
}
if (PodeEnviarNotificacao(u.Id, (int)TipoAviso.NovoFornecedorAvisoMembro, TipoAlerta.SMS))
{
var sms = new Sms
{
UsuarioCriacao = u,
DtCriacao = DateTime.Now,
Numero = u.Telefones.Select(t => t.DddCel).FirstOrDefault() + u.Telefones.Select(t => t.Celular).FirstOrDefault(),
Mensagem = $"Economiza Já - Membro {nomeMembro} - Está querendo comprar com você. Corra para aceitar e comece a fazer novos negocios.",
Status = StatusSms.NaoEnviado,
OrigemSms = TipoOrigemSms.LembreteFornecedorAceiteMembro,
Ativo = true
};
_smsRep.Add(sms);
}
usuarios.Add(u);
_unitOfWork.Commit();
});
});
return(usuarios);
}
public HttpResponseMessage InserirCadastro(HttpRequestMessage request, EnderecoViewModel enderecoViewModel)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (enderecoViewModel.BairroDescNew != null ||
enderecoViewModel.BairroDescNew != "")
{
//remove a validação do bairro quase não tenha achado, pois nesse caso vamos cadastro o digitado manualmente
ModelState.Remove("enderecoViewModel.BairroId");
}
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
if (_enderecoRep.VerificaEnderecoJaCadastrado(enderecoViewModel.Cep, enderecoViewModel.PessoaId) > 0)
{
ModelState.AddModelError("CEP Existente", "CEP:" + enderecoViewModel.Cep + " já existe.");
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
Usuario usuario = _usuarioRep.GetSingle(1);
if (!string.IsNullOrEmpty(enderecoViewModel.BairroDescNew))
{
//var cit = _cidadeRep.GetSingle(fornecedorViewModel.Endereco.CidadeId);
Bairro bairroCad = new Bairro()
{
DescBairro = enderecoViewModel.BairroDescNew,
CidadeId = enderecoViewModel.CidadeId,
DtCriacao = DateTime.Now,
UsuarioCriacao = usuario
};
_bairroRep.Add(bairroCad);
_unitOfWork.Commit();
enderecoViewModel.BairroId = bairroCad.Id;
}
if (_enderecoRep.GetAll().Count(x => x.Pessoa.Id == enderecoViewModel.PessoaId) == 0)
{
enderecoViewModel.EnderecoPadrao = true;
}
Endereco novoEndereco = new Endereco()
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
PessoaId = enderecoViewModel.PessoaId,
EstadoId = enderecoViewModel.EstadoId,
CidadeId = enderecoViewModel.CidadeId,
BairroId = enderecoViewModel.BairroId,
LogradouroId = enderecoViewModel.LogradouroId,
Numero = enderecoViewModel.NumEndereco,
Complemento = enderecoViewModel.Complemento,
DescEndereco = enderecoViewModel.Endereco.Trim(),
Cep = enderecoViewModel.Cep,
Ativo = enderecoViewModel.Ativo,
EnderecoPadrao = enderecoViewModel.EnderecoPadrao,
Referencia = enderecoViewModel.Referencia
};
novoEndereco.LocalizacaoGoogle();
_enderecoRep.Add(novoEndereco);
_unitOfWork.Commit();
Membro membroAtual = _membroRep.FindBy(p => p.PessoaId == enderecoViewModel.PessoaId).FirstOrDefault();
// Update view model
enderecoViewModel = Mapper.Map <Endereco, EnderecoViewModel>(novoEndereco);
response = request.CreateResponse(HttpStatusCode.Created, enderecoViewModel);
}
}
return response;
}));
}
public List <CotacaoUsuarios> PrecificarCotacaoFornecedor()
{
// Verificar se existe fatura em atraso, para não precificar para este fornecedor
List <KeyValuePair <int, DateTime> > listCotacaoId = new List <KeyValuePair <int, DateTime> >();
List <int> categoriasFornecedores = new List <int>();
var fornecedores = _fornecedorProdutoRep.GetAll()
.Where(x => x.Fornecedor.Ativo && x.Ativo)
.Select(f => f.Fornecedor).Distinct().ToList();
fornecedores.ForEach(f =>
{
listCotacaoId.Clear();
categoriasFornecedores.Clear();
var membrosForn = _membroFornecedor.GetAll()
.Where(m => m.FornecedorId == f.Id && m.Ativo)
.Select(o => o.Membro.Id)
.ToList();
var indispProdutoFornecedor = _indisponibilidadeProdutoRep.GetAll()
.Where(i => i.FornecedorId == f.Id &&
i.InicioIndisponibilidade <= DateTime.Now &&
i.FimIndisponibilidade >= DateTime.Now)
.Select(c => c.Produto.Id).ToList();
var resultCotacao = _resultadoCotacao.GetAll()
.Where(x => x.Cotacao.DtFechamento >= DateTime.Now && x.FornecedorId == f.Id)
.Select(c => c.CotacaoId)
.ToList();
var fornecedorCategorias = f.FornecedorCategorias.Select(x => x.CategoriaId).ToList();
//pega todos os pedido da tabela remover fornecedor que estaja na cotação = ProdutoId
var itemPedidos = _cotacaoPedidos.GetAll()
.Where(x => !resultCotacao.Contains(x.CotacaoId) &&
x.Cotacao.DtFechamento >= DateTime.Now)
.SelectMany(i => i.Pedido.ItemPedidos
.Where(r => !indispProdutoFornecedor.Contains(r.ProdutoId) &&
fornecedorCategorias.Contains(r.Produto.SubCategoria.CategoriaId))
.Select(p => p.Id))
.ToList();
// Verifica se o fornecedor foi removido para dar preço no item
var intensPedidoRemoveItemForn = _removeFornPedidoRep
.FindBy(x => x.FonecedorId == f.Id && itemPedidos.Contains(x.ItemPedidoId))
.Select(p => p.ItemPedidoId)
.ToList();
var cotacaoPedidos = _cotacaoPedidos.GetAll()
.Where(x => !resultCotacao.Contains(x.CotacaoId) &&
membrosForn.Contains(x.Pedido.Membro.Id) &&
x.Cotacao.DtFechamento >= DateTime.Now &&
x.Pedido.ItemPedidos.Any(p => !intensPedidoRemoveItemForn.Contains(p.Id) &&
fornecedorCategorias.Contains(p.Produto.SubCategoria.CategoriaId)))
.GroupBy(g => g.CotacaoId)
.ToList();
for (int i = 0; i < cotacaoPedidos.Count; i++)
{
var pedidos = cotacaoPedidos[i].Select(x => x.Pedido).ToList();
var prod = f.Produtos.Select(x => x.ProdutoId).ToList();
var itensCotacao = cotacaoPedidos[i].SelectMany(x => x.Pedido.ItemPedidos.Where(p => prod.Contains(p.ProdutoId)))
.Select(c => new { c.ProdutoId, c.Quantidade })
.GroupBy(s => s.ProdutoId)
.Select(p => new { ProdutoId = p.Key, Quantidade = p.Sum(t => t.Quantidade) })
.ToList();
itensCotacao.ForEach(z =>
{
var categoria = f.Produtos.FirstOrDefault(x => x.ProdutoId == z.ProdutoId).Produto.SubCategoria.CategoriaId;
var existeProduto = f.Produtos.Count(x => x.ProdutoId == z.ProdutoId) > 0;
var existeProdutosFornecedor = f.Produtos.Count(x => x.ProdutoId == z.ProdutoId) > 0 &&
f.Produtos.FirstOrDefault(x => x.ProdutoId == z.ProdutoId).ListaQuantidadeDesconto
.Count(p => p.ValidadeQtdDesconto >= DateTime.Now && p.QuantidadeMinima <= z.Quantidade) > 0;
if (existeProduto)
{
var resultadoCotacao = new ResultadoCotacao();
resultadoCotacao.UsuarioCriacao = f.UsuarioCriacao;
resultadoCotacao.DtCriacao = DateTime.Now;
resultadoCotacao.Ativo = true;
resultadoCotacao.FornecedorId = f.Id;
//resultadoCotacao.Observacao = "Precificação automática";
resultadoCotacao.CotacaoId = cotacaoPedidos[i].FirstOrDefault().CotacaoId;
resultadoCotacao.ProdutoId = z.ProdutoId;
resultadoCotacao.PrecoNegociadoUnit = !f.Produtos.Any() ? 0 :
existeProdutosFornecedor
?
Math.Round((f.Produtos.FirstOrDefault(x => x.ProdutoId == z.ProdutoId).Valor -
(f.Produtos.FirstOrDefault(x => x.ProdutoId == z.ProdutoId)
.ListaQuantidadeDesconto.Where(w => w.QuantidadeMinima <= z.Quantidade).OrderByDescending(ob
=>
ob.QuantidadeMinima).FirstOrDefault().PercentualDesconto *
f.Produtos.FirstOrDefault(x => x.ProdutoId == z.ProdutoId).Valor
) / 100), 2)
:
f.Produtos.FirstOrDefault(x => x.ProdutoId == z.ProdutoId).Valor;
resultadoCotacao.Qtd = z.Quantidade;
_resultadoCotacao.Add(resultadoCotacao);
if (!listCotacaoId.Select(x => x.Key).Contains(resultadoCotacao.CotacaoId))
{
listCotacaoId.Add(new KeyValuePair <int, DateTime>(resultadoCotacao.CotacaoId, cotacaoPedidos[i].FirstOrDefault().Cotacao.DtFechamento));
}
if (!categoriasFornecedores.Contains(categoria))
{
categoriasFornecedores.Add(categoria);
}
}
});
Emails emailPrecificacao = new Emails()
{
EmailDestinatario = f.Pessoa.Usuarios.FirstOrDefault().UsuarioEmail,
CorpoEmail = _templateEmail.GetSingle(34).Template.Replace("#CotacaoId#", cotacaoPedidos[i].FirstOrDefault().CotacaoId.ToString()),
AssuntoEmail = $"Cotação {cotacaoPedidos[i].FirstOrDefault().CotacaoId} respondida automaticamente.",
Status = Status.NaoEnviado,
Origem = Origem.PrecificacaoAutomaticaCotacaoFornecedor,
DtCriacao = DateTime.Now,
UsuarioCriacao = f.Pessoa.Usuarios.FirstOrDefault(),
Ativo = true
};
_emailsRep.Add(emailPrecificacao);
_unitOfWork.Commit();
}
});
var listCotacaoUsuarios = new List <CotacaoUsuarios>();
var fornecedor = this._fornecedoRep.FindBy(x => x.FornecedorCategorias.Any(y => categoriasFornecedores.Contains(y.CategoriaId))).Select(x => x.PessoaId).ToList();
var usuarios = this._usuarioRep.FindBy(x => fornecedor.Contains(x.PessoaId) && !string.IsNullOrEmpty(x.TokenSignalR)).ToList();
if (listCotacaoId.Count > 0 && usuarios.Count > 0)
{
listCotacaoId.ForEach(x =>
{
usuarios.ForEach(u =>
{
var cotacaoGroup = CotacaoProdsGroup(u.Id, (int)x.Key);
listCotacaoUsuarios.Add(new CotacaoUsuarios
{
CotacaoId = x.Key,
TokenUsuario = u.TokenSignalR,
CotacaoGrupo = cotacaoGroup,
DataFechamentoCotacao = x.Value
});
});
});
}
return(listCotacaoUsuarios);
}
public HttpResponseMessage Get(HttpRequestMessage request, int?page, int?pageSize, int?modulo, string filter = null)
{
int currentPage = page.Value;
int currentPageSize = pageSize.Value;
int mod = modulo.Value;
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
List <Menu> menu = null;
int totalMenu = new int();
if (!string.IsNullOrEmpty(filter))
{
filter = filter.Trim().ToLower();
if (mod > 0)
{
menu = _menuRep.FindBy(c => c.ModuloId == mod &&
c.DescMenu.Contains(filter))
.OrderBy(c => c.Modulo.DescModulo).ThenBy(c => c.DescMenu)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalMenu = _menuRep.GetAll()
.Count(c => c.ModuloId == mod &&
c.DescMenu.Contains(filter));
}
else
{
menu = _menuRep.FindBy(c => c.DescMenu.Contains(filter))
.OrderBy(c => c.Modulo.DescModulo)
.ThenBy(c => c.DescMenu)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalMenu = _menuRep.GetAll()
.Count(c => c.DescMenu.Contains(filter));
}
}
else
{
if (mod > 0)
{
menu = _menuRep.GetAll().Where(c => c.ModuloId == mod)
.OrderBy(c => c.Modulo.DescModulo)
.ThenBy(c => c.DescMenu)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalMenu = _menuRep.GetAll().Count(x => x.ModuloId == mod);
}
else
{
menu = _menuRep.GetAll()
.OrderBy(c => c.Modulo.DescModulo)
.ThenBy(c => c.DescMenu)
.Skip(currentPage * currentPageSize)
.Take(currentPageSize)
.ToList();
totalMenu = _menuRep.GetAll().Count();
}
}
IEnumerable <MenuViewModel> menuVM = Mapper.Map <IEnumerable <Menu>, IEnumerable <MenuViewModel> >(menu);
PaginacaoConfig <MenuViewModel> pagSet = new PaginacaoConfig <MenuViewModel>()
{
Page = currentPage,
TotalCount = totalMenu,
TotalPages = (int)Math.Ceiling((decimal)totalMenu / currentPageSize),
Items = menuVM
};
response = request.CreateResponse(HttpStatusCode.OK, pagSet);
return response;
}));
}
public HttpResponseMessage Inserir(HttpRequestMessage request, InserirListaComprasViewModel listaCompras)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var usuario = _usuarioRep.GetSingle(int.Parse(HttpContext.Current.User.Identity.GetUserId()));
if (_listaComprasRep.FindBy(x => x.NomeLista == listaCompras.NomeLista && x.Ativo && x.UsuarioCriacaoId == usuario.Id).Any())
{
ModelState.AddModelError("Lista já Existente", "Lista: " + listaCompras.NomeLista + " já existe .");
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
var membro = _membroRep.GetAll().FirstOrDefault(x => x.PessoaId == usuario.PessoaId);
var lista = new ListaCompras
{
NomeLista = listaCompras.NomeLista,
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
Ativo = true
};
_listaComprasRep.Add(lista);
foreach (var item in listaCompras.ListaCompras)
{
var itemLista = new ListaComprasItem
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
Quantidade = item.quantity,
ProdutoId = item.sku,
Ativo = true,
FlgOutraMarca = item.flgOutraMarca,
QtdForne = item.qtdForn
};
lista.ListaComprasItens.Add(itemLista);
}
_unitOfWork.Commit();
foreach (var item in listaCompras.RemFornPedCot)
{
var removeFornLista = new ListaComprasRemoveForn
{
UsuarioCriacao = usuario,
DtCriacao = DateTime.Now,
FonecedorId = item.forn,
ProdutoId = item.prd,
ListaComprasId = lista.Id,
Ativo = true
};
_listaComprasRemoveFornRep.Add(removeFornLista);
}
_unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.OK);
}
return response;
}));
}
public List <ResultadoCotacao> ListarResultadoCotacao(int cotacaoID)
{
List <ResultadoCotacao> lResultCotacao = _resultadoCotacaoRep.FindBy(rc => rc.CotacaoId == cotacaoID).ToList();
return(lResultCotacao);
}
