Example #1
0
        public static async Task <bool> SaveAsync(Oportunidade oportunidade, int idCliente, string token)
        {
            if (await SeguracaServ.validaTokenAsync(token))
            {
                if (oportunidade.ID == 0)
                {
                    OportunidadeRep rep = new OportunidadeRep();

                    oportunidade.DataCriacao = DateTime.Now;
                    oportunidade.DataEdicao  = DateTime.Now;
                    oportunidade.Ativo       = true;
                    try
                    {
                        rep.Add(oportunidade);
                        if (await EnderecoServ.SaveEnderecoAsync(oportunidade.Endereco, token))
                        {
                            return(false);
                        }

                        return(false);
                    }
                    catch (Exception e)
                    {
                        ///:)
                        return(false);
                    }
                }
                else
                {
                    OportunidadeRep rep = new OportunidadeRep();
                    oportunidade.DataEdicao = DateTime.Now;
                    try
                    {
                        rep.Update(oportunidade);
                        if (await EnderecoServ.RemoveEnderecoAsync(oportunidade.Endereco, token))
                        {
                            await EnderecoServ.SaveEnderecoAsync(oportunidade.Endereco, token);

                            return(true);
                        }

                        return(false);
                    }
                    catch (Exception e)
                    {
                        ///:)
                        return(false);
                    }
                }
            }
            else
            {
                return(false);
            }
        }
Example #2
0
 /// <summary>
 /// Metodo de retornar todos os Propiedadess por cliente
 /// </summary>
 /// <param name="idCliente">ID do cliente solicitante</param>
 /// <param name="token">Token Valido</param>
 /// <returns></returns>
 public static async Task <List <Propiedades> > GetAllAsync(int idCliente, string token)
 {
     if (await SeguracaServ.validaTokenAsync(token))
     {
         return(PropiedadesRep.GetAll().Where(x => x.idCliente == idCliente).ToList());
     }
     else
     {
         return(new List <Propiedades>());
     }
 }
 /// <summary>
 /// Metodo de retornar todos os Transportadoras por cliente
 /// </summary>
 /// <param name="idCliente">ID do cliente solicitante</param>
 /// <param name="token">Token Valido</param>
 /// <returns></returns>
 public static async Task <List <Transportadora> > GetAllAsync(int idCliente, string token)
 {
     if (await SeguracaServ.validaTokenAsync(token))
     {
         return(TransportadoraRep.GetAll().Where(x => x.idCliente == idCliente).ToList());
     }
     else
     {
         return(new List <Transportadora>());
     }
 }
Example #4
0
 public static async Task <IList <Oportunidade> > GetListAsync(int idCliente, string token)
 {
     if (await SeguracaServ.validaTokenAsync(token))
     {
         OportunidadeRep rep = new OportunidadeRep();
         //9 é deletado
         return(rep.GetAll().Where(x => x.Status != 9 && x.IdCliente == idCliente).ToList());
     }
     else
     {
         return(null);
     }
 }
Example #5
0
        /// <summary>
        /// Metodo de deletar produto
        /// </summary>
        /// <param name="produto">Produto que iraser deletado</param>
        /// <param name="token">Token valido</param>
        /// <returns>Verdadeiro: Removeu o produto / Falso: Houve falha</returns>
        public static async Task <bool> RemoveAsync(object produto, string token)
        {
            dynamic objEn = produto;
            string  a     = objEn.ID.ToString();

            if (await SeguracaServ.validaTokenAsync(token))
            {
                Produto obj = ProdutoRep.GetAll().Where(x => x.ID == Convert.ToInt32(a)).FirstOrDefault();
                return(ProdutoRep.Remove(obj));
            }
            else
            {
                return(false);
            }
        }
        /// <summary>
        /// Metodo de deletar Transportadora
        /// </summary>
        /// <param name="Transportadora">Transportadora que iraser deletado</param>
        /// <param name="token">Token valido</param>
        /// <returns>Verdadeiro: Removeu o Transportadora / Falso: Houve falha</returns>
        public static async Task <bool> RemoveAsync(Object Transportadora, string token)
        {
            dynamic objEn = Transportadora;
            string  a     = objEn.ID.ToString();

            if (await SeguracaServ.validaTokenAsync(token))
            {
                Transportadora obj = TransportadoraRep.GetAll().Where(x => x.ID == Convert.ToInt32(a)).FirstOrDefault();
                return(TransportadoraRep.Remove(obj));
            }
            else
            {
                return(false);
            }
        }
Example #7
0
        public static async Task <List <Oportunidade> > GetListByClienteAsync(int idUsuarioCriacao, int idCliente, string token)
        {
            if (await SeguracaServ.validaTokenAsync(token))
            {
                OportunidadeRep      oportunidade = new OportunidadeRep();
                IList <Oportunidade> list         = oportunidade.GetAll().Where(x =>
                                                                                x.UsuarioCriacao == idUsuarioCriacao &&
                                                                                x.IdCliente == idCliente).ToList();

                return(list.OrderBy(x => x.DataOportunidade).ToList());
            }
            else
            {
                return(null);
            }
        }
Example #8
0
 /// <summary>
 /// Metodo de salvar CEP (Async)
 /// </summary>
 /// <param name="CEP"> Objeto Produtp</param>
 /// <param name="token"> Token valido</param>
 /// <returns>Verdadeiro: Salvou o CEP / Falso: Houve falha</returns>
 public static async Task <bool> SaveAsync(CEP CEP, string token)
 {
     if (await SeguracaServ.validaTokenAsync(token))
     {
         if (CEP.idCliente != 0)
         {
             try { return(CEPRep.Save(CEP)); } catch { return(false); }
         }
         else
         {
             return(false);
         }
     }
     else
     {
         return(false);
     }
 }
Example #9
0
 /// <summary>
 /// Metodo de salvar Valor (Async)
 /// </summary>
 /// <param name="Valor"> Objeto Produtp</param>
 /// <param name="token"> Token valido</param>
 /// <returns>Verdadeiro: Salvou o Valor / Falso: Houve falha</returns>
 public static async Task <bool> SaveAsync(Valor Valor, string token)
 {
     if (await SeguracaServ.validaTokenAsync(token))
     {
         if (Valor.idCliente != 0)
         {
             try { return(ValorRep.Save(Valor)); } catch { return(false); }
         }
         else
         {
             return(false);
         }
     }
     else
     {
         return(false);
     }
 }
Example #10
0
 /// <summary>
 /// Metodo de salvar Propiedade (Async)
 /// </summary>
 /// <param name="Propiedade"> Objeto Produtp</param>
 /// <param name="token"> Token valido</param>
 /// <returns>Verdadeiro: Salvou o Propiedade / Falso: Houve falha</returns>
 public static async Task <bool> SaveAsync(Propiedade Propiedade, string token)
 {
     if (await SeguracaServ.validaTokenAsync(token))
     {
         if (Propiedade.idCliente != 0)
         {
             try { return(PropiedadeRep.Save(Propiedade)); } catch { return(false); }
         }
         else
         {
             return(false);
         }
     }
     else
     {
         return(false);
     }
 }
 /// <summary>
 /// Metodo de salvar Transportadora (Async)
 /// </summary>
 /// <param name="Transportadora"> Objeto Produtp</param>
 /// <param name="token"> Token valido</param>
 /// <returns>Verdadeiro: Salvou o Transportadora / Falso: Houve falha</returns>
 public static async Task <bool> SaveAsync(Transportadora Transportadora, string token)
 {
     if (await SeguracaServ.validaTokenAsync(token))
     {
         if (Transportadora.idCliente != 0)
         {
             try { return(TransportadoraRep.Save(Transportadora)); } catch { return(false); }
         }
         else
         {
             return(false);
         }
     }
     else
     {
         return(false);
     }
 }
Example #12
0
 /// <summary>
 /// Metodo de salvar produto (Async)
 /// </summary>
 /// <param name="produto"> Objeto Produtp</param>
 /// <param name="token"> Token valido</param>
 /// <returns>Verdadeiro: Salvou o produto / Falso: Houve falha</returns>
 public static async Task <bool> SaveAsync(Produto produto, string token)
 {
     if (await SeguracaServ.validaTokenAsync(token))
     {
         if (produto.idCliente != 0)
         {
             try { return(ProdutoRep.Save(produto)); } catch { return(false); }
         }
         else
         {
             return(false);
         }
     }
     else
     {
         return(false);
     }
 }
Example #13
0
        /// <summary>
        /// Metodo de salvar Propiedades (Async)
        /// </summary>
        /// <param name="Propiedades"> Objeto Produto</param>
        /// <param name="token"> Token valido</param>
        /// <returns>Verdadeiro: Salvou o Propiedades / Falso: Houve falha</returns>
        public static async Task <bool> SaveAsync(Propiedades Propiedades, string token)
        {
            if (await SeguracaServ.validaTokenAsync(token))
            {
                if (Propiedades.idCliente != 0)
                {
                    int id = PropiedadesRep.Save(Propiedades);

                    //Salva Estrutura
                    try
                    {
                        List <Estrutura> estruturas = new List <Estrutura>();
                        PropiedadesRep.SaveDept(
                            Propiedades.Departamento,
                            Propiedades.UsuarioCriacao,
                            idPropiedade: id,
                            idCliente: Propiedades.idCliente);
                    }
                    catch { return(false); }

                    //Salva Arquivo
                    try
                    {
                        PropiedadesRep.SaveArquivos(
                            Propiedades.ArquivosVinculado,
                            Propiedades.UsuarioCriacao,
                            idPropiedade: id,
                            idCliente: Propiedades.idCliente);
                    }
                    catch { return(false); }

                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            else
            {
                return(false);
            }
        }
Example #14
0
 public static async Task <bool> RemoveAsync(Oportunidade oportunidade, string token)
 {
     if (await SeguracaServ.validaTokenAsync(token))
     {
         try
         {
             oportunidade.Status = 9;
             OportunidadeRep rep = new OportunidadeRep();
             rep.Update(oportunidade);
             return(true);
         }
         catch (Exception e)
         {
             return(false);
         }
     }
     else
     {
         return(false);
     }
 }
Example #15
0
        public async Task <IActionResult> SaveURLAsync([FromRoute] string token, [FromBody] ProfissionalXUrl url)
        {
            try
            {
                var response = default(ProfissionalXUrl);
                if (await SeguracaServ.ValidaTokenAsync(token))
                {
                    response = _urlService.Save(url);
                }
                else
                {
                    throw new Exception("Token inválido.");
                }

                return(Ok(response));
            }
            catch (Exception e)
            {
                return(StatusCode(500, "Não foi possível completar a operação."));
            }
        }
Example #16
0
        public async Task <IActionResult> GetURLByProfissionalAsync([FromRoute] int profissionalId, [FromRoute] int idCliente, [FromRoute] string token)
        {
            try
            {
                var response = default(IEnumerable <ProfissionalXUrl>);
                if (await SeguracaServ.ValidaTokenAsync(token))
                {
                    response = _urlService.GetByProfissionalId(idCliente, profissionalId);
                }
                else
                {
                    throw new Exception("Token inválido.");
                }

                return(Ok(response));
            }
            catch (Exception e)
            {
                return(StatusCode(500, "Não foi possível completar a operação."));
            }
        }
Example #17
0
        /// <summary>
        ///Regras:
        ///Montar Objeto tipo PAC
        ///Consultar principal para colher configurações padores de CLiente
        ///Verificar se o metodo esta automatico ou nem
        ///Retornar uma "Tuple" com todos os meios dde entregas disponiveis
        /// </summary>
        /// <returns></returns>
        public static async Task <List <Tuple <string, double, string, DateTime> > > CalcutatePACFromServiceAsync(int IDProduto, string CEP, int idCliente, int idUsuario, string token)
        {
            if (await SeguracaServ.validaTokenAsync(token))
            {
                //Carrega informações de Configuração de envio
                var config  = SeguracaServ.GetConfig(idCliente, idUsuario);
                var produto = SeguracaServ.GetProduto(idCliente, idUsuario, IDProduto);

                //Carrega MODEL
                PropEnvioPAC propEnvio = new PropEnvioPAC
                {
                    nCdEmpresa          = config.Where(x => x.Chave == "nCdEmpresaPAC").FirstOrDefault().Valor,
                    nCdFormato          = Convert.ToInt32(config.Where(x => x.Chave == "Formato").FirstOrDefault().Valor),
                    nCdServico          = "PAC",
                    nVlAltura           = produto.Altura,
                    nVlComprimento      = produto.Comprimento,
                    nVlDiametro         = 0,
                    nVlLargura          = produto.Largura,
                    nVlPeso             = produto.Peso.ToString(),
                    nVlValorDeclarado   = 0,
                    sCdAvisoRecebimento = "false",
                    sCdMaoPropria       = "false",
                    sCepDestino         = config.Where(x => x.Chave == "CEPDestino").FirstOrDefault().Valor,
                    sCepOrigem          = CEP,
                    sDsSenha            = config.Where(x => x.Chave == "Senha").FirstOrDefault().Valor
                };

                CorreiosServ correios = new CorreiosServ();


                List <Tuple <string, double, string, DateTime> > envio = correios.GetValorFromPAC(propEnvio);

                return(envio);
            }
            else
            {
                return(new List <Tuple <string, double, string, DateTime> >());
            }
        }