示例#1
0
        public ViewResult FormUpdateClientePotencial(string id)
        {
            ClientePotencialViewModel modelo = new ClientePotencialViewModel();

            try
            {
                ClientePotencial retorno = new ClientePotencial();
                //Formulario com os dados do cliente
                if (!String.IsNullOrEmpty(id))
                {
                    //campo que sempre contém valor
                    retorno = clientePotencialData.Get(new Guid(id));


                    if (retorno != null)
                    {
                        modelo.clientePotencial = retorno;

                        //apresenta mensagem de cliente atualizado com sucesso
                        modelo.StatusMessage = StatusMessage;
                    }
                }
            }
            catch (Exception ex)
            {
                LogOsca log = new LogOsca();
                log.GravaLog(1, 1, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormUpdateClientePotencial-get", ex.Message);
            }

            return(View(modelo));
        }
        /// <summary>
        /// Borrar a un Cliente Potencial existente en la base de datos Marketing
        /// </summary>
        public void BorrarClientePotencial(ClientePotencial clientePotencialBO)
        {
            cnn.ConnectionString = cnnStr;
            if (ConnectionState.Closed == cnn.State)
            {
                cnn.Open();
            }


            SqlCommand cmd = new SqlCommand("spBorrarClientePotencial", cnn);

            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.AddWithValue("@ID", clientePotencialBO.ID);

            try
            {
                cmd.ExecuteNonQuery();
            }
            catch
            {
                throw;
            }
            finally
            {
                CloseAll(cmd, cnn);
            }
        }
示例#3
0
 public void Clean()
 {
     elCliente1 = null;
     elCliente2 = null;
     elCliente3 = null;
     elCliente4 = null;
 }
示例#4
0
        public IActionResult FormCreateClientePotencial(ClientePotencialViewModel entrada)
        {
            ClientePotencial modelo = new ClientePotencial();

            entrada.contexto = contexto;

            try
            {
                if (entrada.clientePotencial != null)
                {
                    if (ClientePotencialRules.MontaClientePotencialCreate(entrada, out modelo, contexto))
                    {
                        clientePotencialData.Add(modelo);

                        return(RedirectToAction("FormUpdateClientePotencial", new { id = modelo.id.ToString() }));
                    }
                }
                else
                {
                    //Apresenta mensagem para o usuário
                    return(RedirectToAction("ContexError", "CustomError", new { entityType = 1 }));
                }
            }
            catch (Exception ex)
            {
                LogOsca log = new LogOsca();
                log.GravaLog(1, 1, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormCreateClientePotencial-post", ex.Message);
            }
            return(View());
        }
示例#5
0
        public ClientePotencial Persistir(Model.ClientePotencial Objcliente)
        {
            List <Model.ClientePotencial> lstTempCliente = new List <ClientePotencial>();
            ClientePotencial tmpCliente = null;

            if (Objcliente.ID.HasValue)
            {
                tmpCliente = RepositoryService.ClientePotencial.Retrieve(Objcliente.ID.Value);

                if (tmpCliente != null)
                {
                    Objcliente.ID = tmpCliente.ID;
                    RepositoryService.ClientePotencial.Update(Objcliente);

                    return(Objcliente);
                }
                else
                {
                    return(null);
                }
            }
            else
            {
                Objcliente.ID = RepositoryService.ClientePotencial.Create(Objcliente);
                return(Objcliente);
            }
        }
 public void Clean()
 {
     elCliente1           = null;
     elCliente2           = null;
     presentadorAgregar   = null;
     presentadorModificar = null;
 }
 public void Init()
 {
     elCliente1           = new DominioTangerine.Entidades.M3.ClientePotencial("Prueba", "J-121212121212-4", "*****@*****.**", 121212, 1);
     elCliente2           = new DominioTangerine.Entidades.M3.ClientePotencial("Prueba2", "J-121212121212-4", "*****@*****.**", 121212, 1);
     presentadorAgregar   = new PresentadorAgregarClientePotencial(contratoAgregar);
     presentadorModificar = new PresentadorModificarClientePotencial(contratoModificar);
 }
        public static bool SetStatus(int valor, string idCliente, ClientePotencialData clientePotencialData, ClienteData clienteData, ContextPage contexto, SqlGenericData sqlService)
        {
            ClientePotencial modelo = new ClientePotencial();

            modelo.id                = new Guid(idCliente);
            modelo.modificadoEm      = DateTime.Now;
            modelo.modificadoPor     = contexto.idUsuario;
            modelo.modificadoPorName = contexto.nomeUsuario;
            modelo.statusLead        = (CustomEnumStatus.StatusLead)valor;

            clientePotencialData.SetStatus(modelo);

            //Cria o Objeto Cliente
            if (valor == 2)
            {
                Cliente          cliente          = new Cliente();
                ClientePotencial clientePotencial = new ClientePotencial();
                clientePotencial = sqlService.RetornaClientePotencial(new Guid(idCliente));

                cliente.nomeCliente = clientePotencial.nomeCliente;
                cliente.sexo        = clientePotencial.sexo;

                if (!String.IsNullOrEmpty(clientePotencial.email))
                {
                    cliente.email = clientePotencial.email;
                }

                if (!String.IsNullOrEmpty(clientePotencial.telefone))
                {
                    cliente.telefone = clientePotencial.telefone;
                }

                if (!String.IsNullOrEmpty(clientePotencial.celular))
                {
                    cliente.celular = clientePotencial.celular;
                }

                if (!String.IsNullOrEmpty(clientePotencial.anotacao))
                {
                    cliente.anotacao = clientePotencial.anotacao;
                }

                cliente.codigo = AutoNumber.GeraCodigo(1, contexto.idOrganizacao);

                ////************ Objetos de controle de acesso ***************
                cliente.criadoEm          = DateTime.Now;
                cliente.criadoPor         = contexto.idUsuario;
                cliente.criadoPorName     = contexto.nomeUsuario;
                cliente.modificadoEm      = DateTime.Now;
                cliente.modificadoPor     = contexto.idUsuario;
                cliente.modificadoPorName = contexto.nomeUsuario;
                cliente.idOrganizacao     = contexto.idOrganizacao;
                ////************ FIM Objetos de controle de acesso ***************

                //Cria o novo Cliente
                clienteData.Add(cliente);
            }

            return(true);
        }
        /// <summary>
        /// Actualiza a un Cliente Potencial existente en la base de datos Marketing
        /// </summary>
        public void ActualizarClientePotencial(ClientePotencial clientePotencialBO)
        {
            cnn.ConnectionString = cnnStr;
            if (ConnectionState.Closed == cnn.State)
            {
                cnn.Open();
            }


            SqlCommand cmd = new SqlCommand("spActualizarClientePotencial", cnn);

            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.AddWithValue("@ID", clientePotencialBO.ID);
            cmd.Parameters.AddWithValue("@Nombre", clientePotencialBO.Nombre);
            cmd.Parameters.AddWithValue("@Apellido", clientePotencialBO.Apellido);
            cmd.Parameters.AddWithValue("@Correo", clientePotencialBO.Correo);
            cmd.Parameters.AddWithValue("@Edad", clientePotencialBO.Edad);

            try
            {
                cmd.ExecuteNonQuery();
            }
            catch
            {
                throw;
            }
            finally
            {
                CloseAll(cmd, cnn);
            }
        }
        /// <summary>
        /// Metodo para eliminar a un cliente potencial dentro de la base de datos
        /// </summary>
        /// <param name="parametro"></param>
        /// <returns></returns>
        public bool Eliminar(Entidad parametro)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceClientePotencial.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            ClientePotencial elClientePot = (ClientePotencial)parametro;

            elClientePot.IdClientePotencial = parametro.Id;
            List <Parametro> parameters    = new List <Parametro>();
            BDConexion       theConnection = new BDConexion();
            Parametro        theParam      = new Parametro();

            try
            {
                theParam = new Parametro(ResourceClientePotencial.AidClientePotencial,
                                         SqlDbType.Int, elClientePot.IdClientePotencial.ToString(), false);
                parameters.Add(theParam);

                List <Resultado> results =
                    theConnection.EjecutarStoredProcedure(ResourceClientePotencial.SP_eliminarClientePotencialDef, parameters);
            }

            catch (ArgumentNullException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.M3.NullArgumentExceptionLeads(RecursoGeneralBD.Codigo,
                                                                             RecursoGeneralBD.Mensaje, ex);
            }

            catch (FormatException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExcepcionesTangerine.M3.WrongFormatExceptionLeads(ResourceClientePotencial.Codigo_Error_Formato,
                                                                            ResourceClientePotencial.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesTangerine.ExceptionTGConBD ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw ex;
            }
            catch (SqlException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.ExceptionTGConBD(RecursoGeneralBD.Codigo,
                                                                RecursoGeneralBD.Mensaje, ex);
            }
            catch (Exception ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExcepcionesTangerine.ExceptionsTangerine(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceClientePotencial.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return(true);
        }
示例#11
0
 public void Init()
 {
     elCliente1    = new ClientePotencial("Test2", "J-121212-F", "*****@*****.**", 121212, 1);
     elCliente2    = new ClientePotencial();
     elCliente3    = new ClientePotencial("Test2Cambio", "J-121212-F", "*****@*****.**", 746, 1);
     elCliente4    = new ClientePotencial("Test3", "J-121212-F", "*****@*****.**", 121212, 0);
     losClientes   = new List <Entidad>();
     elSeguimiento = new SeguimientoCliente(new DateTime(2016, 05, 02), "Llamada", "Prueba de seguimiento", 5);
 }
 public void clean()
 {
     elCliente1  = null;
     elCliente2  = null;
     elCliente3  = null;
     elCliente4  = null;
     losClientes = null;
     llamadas    = null;
     visitas     = null;
 }
示例#13
0
        public void SetStatus(ClientePotencial modelo)
        {
            db.Attach(modelo);
            db.Entry(modelo).Property("status").IsModified            = true;
            db.Entry(modelo).Property("statusLead").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();
        }
示例#14
0
        public static bool MontaClientePotencialUpdate(ClientePotencialViewModel entrada, out ClientePotencial modelo, ContextPage contexto)
        {
            modelo = new ClientePotencial();
            modelo = entrada.clientePotencial;

            ////************ Objetos de controle de acesso ***************
            modelo.modificadoEm      = DateTime.Now;
            modelo.modificadoPor     = contexto.idUsuario;
            modelo.modificadoPorName = contexto.nomeUsuario;
            ////************ FIM Objetos de controle de acesso ***************

            return(true);
        }
示例#15
0
        public T BuscarPor(ClientePotencial cliente)
        {
            var query = GetQueryExpression <T>(true);

            query.ColumnSet.AllColumns = true;
            query.Criteria.Conditions.Add(new ConditionExpression("originatingleadid", ConditionOperator.Equal, cliente.Id));
            query.Orders.Add(new OrderExpression("name", OrderType.Ascending));
            var colecao = this.RetrieveMultiple(query);

            if (colecao.List.Count == 0)
            {
                return(default(T));
            }
            return(colecao.List[0]);
        }
示例#16
0
        public void Update(ClientePotencial modelo)
        {
            db.Attach(modelo);
            db.Entry(modelo).Property("nomeCliente").IsModified = true;
            db.Entry(modelo).Property("telefone").IsModified    = true;
            db.Entry(modelo).Property("celular").IsModified     = true;

            db.Entry(modelo).Property("email").IsModified             = true;
            db.Entry(modelo).Property("anotacao").IsModified          = true;
            db.Entry(modelo).Property("sexo").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();
        }
示例#17
0
        /// <summary>
        /// Realiza el borrado del Cliente Potencial seleccionado en el GridView
        /// </summary>
        /// <param name="idCliente">ID del Cliente Potencial seleccionado</param>
        public void BorrarCliente(int idCliente)
        {
            #region Datos Cliente Potencial

            ClientePotencialBAL borrarCliente = new ClientePotencialBAL();
            ClientePotencial    cliente       = new ClientePotencial();

            cliente.ID = idCliente;

            #endregion

            #region Borrar Cliente Seleccionado

            borrarCliente.BorrarClientePotencial(cliente);

            #endregion
        }
示例#18
0
        public int?ObterRazaoStatusClientePotencial(ClientePotencial clientePotencial)
        {
            int?razaostatus = 993520003;

            if (clientePotencial.RazaoStatus == 1)
            {
                razaostatus = 993520003;
            }
            else if (clientePotencial.RazaoStatus == 2)
            {
                if (clientePotencial.StageId != null)
                {
                    if ((clientePotencial.StageId.Value.ToString().ToUpper() == "00D0B952-45A4-3C15-E2A3-04E57485816E") || (clientePotencial.StageId.Value.ToString().ToUpper() == "B25D7A8D-C61D-1103-492C-AE77C795C9EE"))
                    {
                        razaostatus = 993520005;
                    }
                    if ((clientePotencial.StageId.Value.ToString().ToUpper() == "8AA82057-E761-70CE-4A4C-0184CA48D938") || (clientePotencial.StageId.Value.ToString().ToUpper() == "5106C715-92B3-0C12-3503-D3810765A259"))
                    {
                        razaostatus = 993520006;
                    }
                }
            }
            else if (clientePotencial.RazaoStatus == 3)
            {
                razaostatus = 993520007;
            }
            else if ((clientePotencial.RazaoStatus == 4) || (clientePotencial.RazaoStatus == 5))
            {
                razaostatus = 993520000;
            }
            else if ((clientePotencial.RazaoStatus == 6) || (clientePotencial.RazaoStatus == 7))
            {
                razaostatus = 993520002;
            }
            else
            {
                razaostatus = clientePotencial.RazaoStatus;
            }
            return(razaostatus);
        }
示例#19
0
        public IActionResult FormUpdateClientePotencial(ClientePotencialViewModel entrada)
        {
            ClientePotencial modelo = new ClientePotencial();

            try
            {
                if (ClientePotencialRules.MontaClientePotencialUpdate(entrada, out modelo, this.contexto))
                {
                    clientePotencialData.Update(modelo);
                    StatusMessage = "Registro Atualizado com Sucesso!";

                    return(RedirectToAction("FormUpdateClientePotencial", new { id = modelo.id.ToString(), idOrg = contexto.idOrganizacao }));
                }
            }
            catch (Exception ex)
            {
                LogOsca log = new LogOsca();
                log.GravaLog(1, 1, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormUpdateClientePotencial-post", ex.Message);
            }

            return(RedirectToAction("FormUpdateClientePotencial", new { id = modelo.id.ToString() }));
        }
示例#20
0
        public IActionResult FormularioEntrada(PaginaClienteViewModel entrada)
        {
            ClientePotencial modelo = new ClientePotencial();


            if (entrada.clientePotencial != null)
            {
                if (ClientePotencialRules.MontaClientePotencialCreateFomulario(entrada, out modelo, new Guid(idOrganizacao)))
                {
                    clientePotencialData.Add(modelo);
                    StatusMessageLead = "Enviado com Sucesso!";
                    return(RedirectToAction("FormularioEntrada", new { id = idOrganizacao }));
                }
            }
            else
            {
                //Apresenta mensagem para o usuário
                return(RedirectToAction("ContexError", "CustomError", new { entityType = 1 }));
            }

            return(View());
        }
示例#21
0
        public static bool MontaClientePotencialCreate(ClientePotencialViewModel entrada, out ClientePotencial modelo, ContextPage contexto)
        {
            modelo = new ClientePotencial();

            if (entrada.contexto.idOrganizacao != null)
            {
                modelo = entrada.clientePotencial;

                ////************ Objetos de controle de acesso ***************
                modelo.criadoEm          = DateTime.Now;
                modelo.criadoPor         = contexto.idUsuario;
                modelo.criadoPorName     = contexto.nomeUsuario;
                modelo.modificadoEm      = DateTime.Now;
                modelo.modificadoPor     = contexto.idUsuario;
                modelo.modificadoPorName = contexto.nomeUsuario;
                modelo.idOrganizacao     = contexto.idOrganizacao;
                ////************ FIM Objetos de controle de acesso ***************


                return(true);
            }

            return(false);
        }
示例#22
0
        public static bool MontaClientePotencialCreateFomulario(PaginaClienteViewModel entrada, out ClientePotencial modelo, Guid idOrganizacao)
        {
            modelo = new ClientePotencial();

            if (entrada.clientePotencial != null)
            {
                modelo = entrada.clientePotencial;

                ////************ Objetos de controle de acesso ***************
                modelo.criadoEm          = DateTime.Now;
                modelo.criadoPor         = new Guid("6E835F74-5249-4B36-AF2E-21F89D1E5964");
                modelo.criadoPorName     = "OscaAdmin";
                modelo.modificadoEm      = DateTime.Now;
                modelo.modificadoPor     = new Guid("6E835F74-5249-4B36-AF2E-21F89D1E5964");
                modelo.modificadoPorName = "OscaAdmin";
                modelo.idOrganizacao     = idOrganizacao;
                ////************ FIM Objetos de controle de acesso ***************


                return(true);
            }

            return(false);
        }
示例#23
0
        public Oportunidade DefinirPropriedades2(Intelbras.Message.Helper.MSG0268 xml, ClientePotencial ClientePotencial)
        {
            #region Propriedades Crm->Xml

            var crm2 = new Servicos.RepositoryService().Oportunidade.BuscarPor(ClientePotencial);

            if (crm2 != null)
            {
                crm2.IntegrarNoPlugin = true;

                crm2.NumeroProjeto = ClientePotencial.NumeroProjeto;

                if (!String.IsNullOrEmpty(xml.CodigoRevenda) && xml.CodigoRevenda.Length == 36)
                {
                    if ((crm2.RevendaIntegrador == null) || (crm2.RevendaIntegrador.Id.ToString() != xml.CodigoRevenda))
                    {
                        crm2.RevendaIntegrador = new Lookup(new Guid(xml.CodigoRevenda), "");
                    }
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "CodigoRevenda não enviado ou fora do padrão (Guid).";
                    return(crm2);
                }

                Contato executivo = new Intelbras.CRM2013.Domain.Servicos.ContatoService(this.Organizacao, this.IsOffline).BuscaContato(new Guid(xml.CodigoExecutivo));
                if (executivo != null)
                {
                    if ((crm2.Executivo == null) || (crm2.Executivo.Id != executivo.ID.Value))
                    {
                        crm2.Executivo = new Lookup(executivo.ID.Value, "");
                    }
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "CodigoExecutivo não encontrado no Crm.";
                    return(crm2);
                }

                if (xml.DataEnvioCotacao.HasValue)
                {
                    crm2.DataEnvioCotacao = xml.DataEnvioCotacao;
                }
                else
                {
                    crm2.DataEnvioCotacao = null;
                }

                if (xml.TeveReuniao.HasValue)
                {
                    crm2.TeveReuniao = xml.TeveReuniao;
                }
                else
                {
                    crm2.TeveReuniao = (Int32)this.PreencherAtributoVazio("int");
                }

                if (xml.DataReuniao.HasValue)
                {
                    crm2.DataReuniao = xml.DataReuniao;
                }
                else
                {
                    crm2.DataReuniao = null;
                }

                if (xml.DataEstimativaAprovacao.HasValue)
                {
                    crm2.DataEstimativaAprovacao = xml.DataEstimativaAprovacao;
                }
                else
                {
                    crm2.DataEstimativaAprovacao = null;
                }

                if (xml.PropostaAprovada.HasValue)
                {
                    crm2.PropostaAprovada = xml.PropostaAprovada;
                }
                else
                {
                    crm2.PropostaAprovada = (Int32)PreencherAtributoVazio("int");
                }

                if (xml.DataAprovacao.HasValue)
                {
                    crm2.DataAprovacao = xml.DataAprovacao;
                }
                else
                {
                    crm2.DataAprovacao = null;
                }

                if (xml.DataEnvioPedidos.HasValue)
                {
                    crm2.DataEnvioPedidos = xml.DataEnvioPedidos;
                }
                else
                {
                    crm2.DataEnvioPedidos = null;
                }

                if (xml.PedidosFaturados.HasValue)
                {
                    crm2.PedidosFaturados = xml.PedidosFaturados;
                }
                else
                {
                    crm2.PedidosFaturados = 993520001;
                }

                #endregion

                return(crm2);
            }
            return(null);
        }
示例#24
0
 public string Enviar(ClientePotencial objModel)
 {
     return(String.Empty);
 }
        /// <summary>
        /// Metodo para promover a un cliente dentro de la base de datos
        /// </summary>
        /// <param name="parametro"></param>
        /// <returns>Un cliente potencial</returns>
        public Entidad ConsultarXId(Entidad parametro)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceClientePotencial.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            ClientePotencial cliente       = (ClientePotencial)parametro;
            List <Parametro> parameters    = new List <Parametro>();
            BDConexion       theConnection = new BDConexion();
            Parametro        theParam      = new Parametro();

            List <ClientePotencial> listClientePotencial = new List <ClientePotencial>();
            ClientePotencial        elClientePotencial   = null;

            try
            {
                theConnection.Conectar();

                theParam = new Parametro(ResourceClientePotencial.AidClientePotencial, SqlDbType.Int,
                                         cliente.Id.ToString(), false);
                parameters.Add(theParam);

                DataTable dt =
                    theConnection.EjecutarStoredProcedureTuplas(ResourceClientePotencial.SP_consultarClientePotencial, parameters);

                //Por cada fila de la tabla voy a guardar los datos
                foreach (DataRow row in dt.Rows)
                {
                    int    IdClientePotencial         = int.Parse(row[ResourceClientePotencial.idClientePotencial].ToString());
                    String NombreClientePotencial     = row[ResourceClientePotencial.nombreClientePotencial].ToString();
                    String RifClientePotencial        = row[ResourceClientePotencial.rifClientePotencial].ToString();
                    String EmailClientePotencial      = row[ResourceClientePotencial.emailClientePotencial].ToString();
                    float  PresupuestoAnual_inversion = float.Parse(row[ResourceClientePotencial.presupuestoAnual_inversion].ToString());
                    int    NumeroLlamadas             = int.Parse(row[ResourceClientePotencial.numeroLlamadas].ToString());
                    int    NumeroVisitas = int.Parse(row[ResourceClientePotencial.numeroVisitas].ToString());
                    int    Status        = int.Parse(row[ResourceClientePotencial.status].ToString());

                    elClientePotencial = new DominioTangerine.Entidades.M3.ClientePotencial(IdClientePotencial, NombreClientePotencial, RifClientePotencial,
                                                                                            EmailClientePotencial, PresupuestoAnual_inversion, NumeroLlamadas, NumeroVisitas, Status);
                }
            }
            catch (ArgumentNullException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.M3.NullArgumentExceptionLeads(RecursoGeneralBD.Codigo,
                                                                             RecursoGeneralBD.Mensaje, ex);
            }
            catch (SqlException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.ExceptionTGConBD(RecursoGeneralBD.Codigo,
                                                                RecursoGeneralBD.Mensaje, ex);
            }
            catch (FormatException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExcepcionesTangerine.M3.WrongFormatExceptionLeads(ResourceClientePotencial.Codigo_Error_Formato,
                                                                            ResourceClientePotencial.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesTangerine.ExceptionTGConBD ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw ex;
            }
            catch (Exception ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExcepcionesTangerine.ExceptionsTangerine(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceClientePotencial.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return(elClientePotencial);
        }
        /// <summary>
        /// Metodo para modificar a un cliente potencial dentro de la base de datos
        /// </summary>
        /// <param name="parametro"></param>
        /// <returns></returns>
        public bool Modificar(Entidad parametro)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceClientePotencial.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
            ClientePotencial elClientePotencial = (ClientePotencial)parametro;
            List <Parametro> parameters         = new List <Parametro>();
            BDConexion       theConnection      = new BDConexion();
            Parametro        theParam           = new Parametro();

            try
            {
                theParam = new Parametro(ResourceClientePotencial.AidClientePotencial, SqlDbType.Int,
                                         elClientePotencial.IdClientePotencial.ToString(), false);
                parameters.Add(theParam);

                theParam = new Parametro(ResourceClientePotencial.AnombreClientePotencial, SqlDbType.VarChar,
                                         elClientePotencial.NombreClientePotencial, false);
                parameters.Add(theParam);

                theParam = new Parametro(ResourceClientePotencial.ArifClientePotencial, SqlDbType.VarChar,
                                         elClientePotencial.RifClientePotencial, false);
                parameters.Add(theParam);

                theParam = new Parametro(ResourceClientePotencial.AemailClientePotencial, SqlDbType.VarChar,
                                         elClientePotencial.EmailClientePotencial, false);
                parameters.Add(theParam);

                theParam = new Parametro(ResourceClientePotencial.ApresupuestoAnualInversion, SqlDbType.Decimal,
                                         elClientePotencial.PresupuestoAnual_inversion.ToString(), false);
                parameters.Add(theParam);

                theParam = new Parametro(ResourceClientePotencial.AnumLlamadas, SqlDbType.Int,
                                         elClientePotencial.NumeroLlamadas.ToString(), false);
                parameters.Add(theParam);

                theParam = new Parametro(ResourceClientePotencial.AnumVisitas, SqlDbType.Int,
                                         elClientePotencial.NumeroVisitas.ToString(), false);
                parameters.Add(theParam);

                List <Resultado> results =
                    theConnection.EjecutarStoredProcedure(ResourceClientePotencial.SP_modificarClientePotencial, parameters);
            }
            catch (ArgumentNullException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.M3.NullArgumentExceptionLeads(RecursoGeneralBD.Codigo,
                                                                             RecursoGeneralBD.Mensaje, ex);
            }
            catch (SqlException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.ExceptionTGConBD(RecursoGeneralBD.Codigo,
                                                                RecursoGeneralBD.Mensaje, ex);
            }
            catch (FormatException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExcepcionesTangerine.M3.WrongFormatExceptionLeads(ResourceClientePotencial.Codigo_Error_Formato,
                                                                            ResourceClientePotencial.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesTangerine.ExceptionTGConBD ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw ex;
            }
            catch (Exception ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExcepcionesTangerine.ExceptionsTangerine(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceClientePotencial.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return(true);
        }
示例#27
0
        public string Enviar(ClientePotencial objModel)
        {
            string resposta = string.Empty;

            return(resposta);
        }
示例#28
0
        public string Executar(string mensagem, string numeroMensagem, Domain.Model.Usuario usuario)
        {
            try
            {
                usuarioIntegracao = usuario;
                ClientePotencial clientePotencialConsulta = null;
                Oportunidade     oportunidadeConsulta     = null;

                var xml = this.CarregarMensagem <Pollux.MSG0269>(mensagem);
                Pollux.Entities.ProjetoItem projetoItem = new Pollux.Entities.ProjetoItem();

                if (!string.IsNullOrEmpty(xml.NumeroProjeto))
                {
                    clientePotencialConsulta = new Servicos.LeadService(this.Organizacao, this.IsOffline).ObterPorNumeroProjeto(xml.NumeroProjeto);
                    if (clientePotencialConsulta != null)
                    {
                        oportunidadeConsulta = new Servicos.RepositoryService().Oportunidade.BuscarPor(clientePotencialConsulta);
                    }

                    if (clientePotencialConsulta == null)
                    {
                        resultadoPersistencia.Sucesso  = false;
                        resultadoPersistencia.Mensagem = "Valor do parâmetro " + xml.NumeroProjeto + " não encontrado.";
                        retorno.Add("Resultado", resultadoPersistencia);
                        return(CriarMensagemRetorno <Pollux.MSG0269R1>(numeroMensagem, retorno));
                    }
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Parâmetro obrigatório para a consulta não enviado.";
                    retorno.Add("Resultado", resultadoPersistencia);
                    return(CriarMensagemRetorno <Pollux.MSG0269R1>(numeroMensagem, retorno));
                }

                if (oportunidadeConsulta != null)
                {
                    projetoItem.NumeroProjeto          = clientePotencialConsulta.NumeroProjeto;
                    projetoItem.ClassificacaoProjeto   = 993520001;
                    projetoItem.CodigoClientePotencial = oportunidadeConsulta.ClientePotencialOriginador.Id.ToString();
                    projetoItem.CodigoOportunidade     = oportunidadeConsulta.Id.ToString();
                    projetoItem.SituacaoProjeto        = ObterRazaoStatusOportunidade(oportunidadeConsulta);
                    if (oportunidadeConsulta.RevendaIntegrador != null)
                    {
                        projetoItem.CodigoRevenda = oportunidadeConsulta.RevendaIntegrador.Id.ToString();
                        projetoItem.NomeRevenda   = oportunidadeConsulta.RevendaIntegrador.Name;
                    }

                    if (oportunidadeConsulta.Distribuidor != null)
                    {
                        projetoItem.CodigoDistribuidor = oportunidadeConsulta.Distribuidor.Id.ToString();
                        projetoItem.NomeDistribuidor   = oportunidadeConsulta.Distribuidor.Name;
                    }
                    if (oportunidadeConsulta.Executivo != null)
                    {
                        projetoItem.CodigoExecutivo = oportunidadeConsulta.Executivo.Id.ToString();
                        projetoItem.NomeExecutivo   = oportunidadeConsulta.Executivo.Name;
                    }
                    projetoItem.CNPJCliente        = clientePotencialConsulta.Cnpj.Replace("-", "").Replace(".", "").Replace("/", "").Trim();
                    projetoItem.RazaoSocial        = clientePotencialConsulta.NomeDaEmpresa;
                    projetoItem.NomeContatoCliente = clientePotencialConsulta.NomeCompletoDoContato;
                    if (!string.IsNullOrEmpty(clientePotencialConsulta.TelefoneComercial))
                    {
                        projetoItem.TelefoneContatoCliente = clientePotencialConsulta.TelefoneComercial;
                    }
                    projetoItem.EmailContatoCliente = clientePotencialConsulta.Email;
                    projetoItem.TipoProjeto         = clientePotencialConsulta.TipoProjeto;
                    if (clientePotencialConsulta.EnvolverEngenharia)
                    {
                        projetoItem.EnvolverEngenharia = 993520000;
                    }
                    else
                    {
                        projetoItem.EnvolverEngenharia = 993520001;
                    }
                    projetoItem.ReceitaEstimada        = clientePotencialConsulta.ValorEstimado;
                    projetoItem.DataPrevisaoFechamento = clientePotencialConsulta.DataEstimada;
                    UnidadeNegocio unidadeNegocio = new Servicos.UnidadeNegocioService(this.Organizacao, this.IsOffline).BuscaUnidadeNegocio(clientePotencialConsulta.UnidadeNegocio.Id);
                    if (unidadeNegocio != null)
                    {
                        projetoItem.CodigoUnidadeNegocio = unidadeNegocio.ChaveIntegracao;
                        projetoItem.NomeUnidadeNegocio   = unidadeNegocio.Nome;
                    }
                    projetoItem.DataCadastro     = clientePotencialConsulta.DataCriacao;
                    projetoItem.DescricaoProjeto = clientePotencialConsulta.Descricao;
                    if (clientePotencialConsulta.CotacaoEnviada.HasValue)
                    {
                        projetoItem.CotacaoEnviada = clientePotencialConsulta.CotacaoEnviada;
                    }
                    if (oportunidadeConsulta.DataEnvioCotacao.HasValue)
                    {
                        projetoItem.DataEnvioCotacao = oportunidadeConsulta.DataEnvioCotacao;
                    }
                    if (oportunidadeConsulta.TeveReuniao.HasValue)
                    {
                        projetoItem.TeveReuniao = oportunidadeConsulta.TeveReuniao;
                    }
                    if (oportunidadeConsulta.DataReuniao.HasValue)
                    {
                        projetoItem.DataReuniao = oportunidadeConsulta.DataReuniao;
                    }
                    if (oportunidadeConsulta.DataEstimativaAprovacao.HasValue)
                    {
                        projetoItem.DataEstimativaAprovacao = oportunidadeConsulta.DataEstimativaAprovacao;
                    }
                    if (oportunidadeConsulta.PropostaAprovada.HasValue)
                    {
                        projetoItem.PropostaAprovada = oportunidadeConsulta.PropostaAprovada;
                    }
                    if (oportunidadeConsulta.DataAprovacao.HasValue)
                    {
                        projetoItem.DataAprovacao = oportunidadeConsulta.DataAprovacao;
                    }
                    if (oportunidadeConsulta.DataEnvioPedidos.HasValue)
                    {
                        projetoItem.DataEnvioPedidos = oportunidadeConsulta.DataEnvioPedidos;
                    }
                    if (oportunidadeConsulta.PedidosFaturados.HasValue)
                    {
                        projetoItem.PedidosFaturados = oportunidadeConsulta.PedidosFaturados;
                    }
                    Usuario proprietarioOportunidade = new Servicos.UsuarioService(this.Organizacao, this.IsOffline).BuscarProprietario("opportunity", "opportunityid", oportunidadeConsulta.Id);
                    if (proprietarioOportunidade != null)
                    {
                        projetoItem.CodigoExecutivoIntelbras = proprietarioOportunidade.Id.ToString();
                        projetoItem.NomeExecutivoIntelbras   = proprietarioOportunidade.NomeCompleto;
                    }
                }
                else
                {
                    projetoItem.NumeroProjeto          = clientePotencialConsulta.NumeroProjeto;
                    projetoItem.ClassificacaoProjeto   = 993520000;
                    projetoItem.CodigoClientePotencial = clientePotencialConsulta.Id.ToString();
                    projetoItem.SituacaoProjeto        = ObterRazaoStatusClientePotencial(clientePotencialConsulta);
                    if (clientePotencialConsulta.RevendaIntegrador != null)
                    {
                        projetoItem.CodigoRevenda = clientePotencialConsulta.RevendaIntegrador.Id.ToString();
                        projetoItem.NomeRevenda   = clientePotencialConsulta.RevendaIntegrador.Name;
                    }
                    if (clientePotencialConsulta.Distribuidor != null)
                    {
                        projetoItem.CodigoDistribuidor = clientePotencialConsulta.Distribuidor.Id.ToString();
                        projetoItem.NomeDistribuidor   = clientePotencialConsulta.Distribuidor.Name;
                    }
                    if (clientePotencialConsulta.Executivo != null)
                    {
                        projetoItem.CodigoExecutivo = clientePotencialConsulta.Executivo.Id.ToString();
                        projetoItem.NomeExecutivo   = clientePotencialConsulta.Executivo.Name;
                    }
                    projetoItem.CNPJCliente        = clientePotencialConsulta.Cnpj.Replace("-", "").Replace(".", "").Replace("/", "").Trim();
                    projetoItem.RazaoSocial        = clientePotencialConsulta.NomeDaEmpresa;
                    projetoItem.NomeContatoCliente = clientePotencialConsulta.NomeCompletoDoContato;
                    if (!string.IsNullOrEmpty(clientePotencialConsulta.TelefoneComercial))
                    {
                        projetoItem.TelefoneContatoCliente = clientePotencialConsulta.TelefoneComercial;
                    }
                    projetoItem.EmailContatoCliente = clientePotencialConsulta.Email;
                    projetoItem.TipoProjeto         = clientePotencialConsulta.TipoProjeto;
                    if (clientePotencialConsulta.EnvolverEngenharia)
                    {
                        projetoItem.EnvolverEngenharia = 993520000;
                    }
                    else
                    {
                        projetoItem.EnvolverEngenharia = 993520001;
                    }
                    projetoItem.ReceitaEstimada        = clientePotencialConsulta.ValorEstimado;
                    projetoItem.DataPrevisaoFechamento = clientePotencialConsulta.DataEstimada;
                    UnidadeNegocio unidadeNegocio = new Servicos.UnidadeNegocioService(this.Organizacao, this.IsOffline).BuscaUnidadeNegocio(clientePotencialConsulta.UnidadeNegocio.Id);
                    if (unidadeNegocio != null)
                    {
                        projetoItem.CodigoUnidadeNegocio = unidadeNegocio.ChaveIntegracao;
                        projetoItem.NomeUnidadeNegocio   = unidadeNegocio.Nome;
                    }
                    projetoItem.DataCadastro     = clientePotencialConsulta.DataCriacao;
                    projetoItem.DescricaoProjeto = clientePotencialConsulta.Descricao;
                    if (clientePotencialConsulta.CotacaoEnviada.HasValue)
                    {
                        projetoItem.CotacaoEnviada = clientePotencialConsulta.CotacaoEnviada;
                    }

                    Usuario proprietario = new Servicos.UsuarioService(this.Organizacao, this.IsOffline).BuscarProprietario("lead", "leadid", clientePotencialConsulta.Id);
                    if (proprietario != null)
                    {
                        projetoItem.CodigoExecutivoIntelbras = proprietario.Id.ToString();
                        projetoItem.NomeExecutivoIntelbras   = proprietario.NomeCompleto;
                    }

                    if (clientePotencialConsulta.TipoSolucao.HasValue)
                    {
                        projetoItem.TipoSolucao = clientePotencialConsulta.TipoSolucao;
                    }
                }
                #region Endereço
                projetoItem.EnderecoClienteFinal = new Pollux.Entities.Endereco();
                if (!string.IsNullOrEmpty(clientePotencialConsulta.Endereco1CEP))
                {
                    projetoItem.EnderecoClienteFinal.CEP = clientePotencialConsulta.Endereco1CEP.Replace("-", "").PadLeft(8, '0');
                }
                ;
                projetoItem.EnderecoClienteFinal.Logradouro = clientePotencialConsulta.Endereco1Rua;
                projetoItem.EnderecoClienteFinal.Numero     = clientePotencialConsulta.Endereco1Numero;
                if (!string.IsNullOrEmpty(clientePotencialConsulta.Endereco1Complemento))
                {
                    projetoItem.EnderecoClienteFinal.Complemento = clientePotencialConsulta.Endereco1Complemento;
                }
                projetoItem.EnderecoClienteFinal.Bairro = clientePotencialConsulta.Endereco1Bairro;

                if (clientePotencialConsulta.Endereco1Municipioid != null)
                {
                    Municipio municipio = new Servicos.MunicipioServices(this.Organizacao, this.IsOffline).ObterPor(clientePotencialConsulta.Endereco1Municipioid.Id);
                    projetoItem.EnderecoClienteFinal.NomeCidade = municipio.Nome;
                    projetoItem.EnderecoClienteFinal.Cidade     = municipio.ChaveIntegracao;
                }
                if (clientePotencialConsulta.Endereco1Estadoid != null)
                {
                    Estado estado = new Servicos.EstadoServices(this.Organizacao, this.IsOffline).BuscaEstadoPorId(clientePotencialConsulta.Endereco1Estadoid.Id);
                    if (estado != null)
                    {
                        projetoItem.EnderecoClienteFinal.UF     = estado.SiglaUF;
                        projetoItem.EnderecoClienteFinal.Estado = estado.ChaveIntegracao;
                    }
                }
                if (clientePotencialConsulta.Endereco1Pais != null)
                {
                    Pais pais = new Servicos.PaisServices(this.Organizacao, this.IsOffline).BuscaPais(clientePotencialConsulta.Endereco1Pais.Id);
                    if (pais != null)
                    {
                        projetoItem.EnderecoClienteFinal.NomePais = pais.Nome;
                        projetoItem.EnderecoClienteFinal.Pais     = pais.Nome;
                    }
                }

                #endregion

                #region Atividades Projeto
                projetoItem.ListaAtividadesProjeto = new List <Pollux.Entities.AtividadeProjeto>();

                List <Postagem> lstAtividadesClientePotencial = new Servicos.PostagemService(this.Organizacao, this.IsOffline).ListarPorReferenteA(clientePotencialConsulta.Id);

                if (oportunidadeConsulta != null)
                {
                    List <Postagem> lstAtividadesOportunidade = new Servicos.PostagemService(this.Organizacao, this.IsOffline).ListarPorReferenteA(oportunidadeConsulta.Id);

                    if (lstAtividadesOportunidade.Count > 0)
                    {
                        foreach (Postagem postagem in lstAtividadesOportunidade)
                        {
                            Pollux.Entities.AtividadeProjeto atividadeProjeto = new Pollux.Entities.AtividadeProjeto();

                            atividadeProjeto.DataAtividade      = postagem.CriadoEm;
                            atividadeProjeto.CodigoContato      = postagem.UsuarioAtividade.Id.ToString();
                            atividadeProjeto.UsuarioAtividade   = postagem.UsuarioAtividade.Name;
                            atividadeProjeto.DescricaoAtividade = postagem.Texto;

                            projetoItem.ListaAtividadesProjeto.Add(atividadeProjeto);
                        }
                    }
                }
                if (lstAtividadesClientePotencial.Count > 0)
                {
                    foreach (Postagem postagem in lstAtividadesClientePotencial)
                    {
                        Pollux.Entities.AtividadeProjeto atividadeProjeto = new Pollux.Entities.AtividadeProjeto();

                        atividadeProjeto.DataAtividade      = postagem.CriadoEm;
                        atividadeProjeto.CodigoContato      = postagem.UsuarioAtividade.Id.ToString();
                        atividadeProjeto.UsuarioAtividade   = postagem.UsuarioAtividade.Name;
                        atividadeProjeto.DescricaoAtividade = postagem.Texto;

                        projetoItem.ListaAtividadesProjeto.Add(atividadeProjeto);
                    }
                }
                #endregion

                #region Anexos Projeto
                projetoItem.ListaAnexosProjeto = new List <Pollux.Entities.AnexoProjeto>();
                if (oportunidadeConsulta != null)
                {
                    List <DocumentoSharePoint> lstAnexosOportunidade = new Servicos.SharePointSiteService(this.Organizacao, this.IsOffline).ListarPorIdRegistro(oportunidadeConsulta.ID.Value);

                    foreach (DocumentoSharePoint anexo in lstAnexosOportunidade)
                    {
                        try
                        {
                            string urlSite         = ConfigurationManager.GetSettingValue("UrlSiteSharePoint");
                            string urlFolderDetail = "";
                            if (!string.IsNullOrEmpty(anexo.UrlAbsoluta))
                            {
                                urlFolderDetail = anexo.UrlAbsoluta;
                            }
                            else if (!string.IsNullOrEmpty(anexo.UrlRelativa))
                            {
                                urlFolderDetail = urlSite + "/opportunity/" + anexo.UrlRelativa;
                            }
                            using (ClientContext spClientContext = new ClientContext(urlSite))
                            {
                                spClientContext.Credentials = new NetworkCredential(usuarioSharePoint, senhaSharePoint, domain);
                                var rootWeb = spClientContext.Web;

                                Folder pastaPrincipal = rootWeb.GetFolderByServerRelativeUrl(urlFolderDetail);

                                if (pastaPrincipal.Files.AreItemsAvailable)
                                {
                                    spClientContext.Load(pastaPrincipal, fs => fs.Files, p => p.Folders);
                                    spClientContext.ExecuteQuery();
                                    FolderCollection folderCollection = pastaPrincipal.Folders;
                                    FileCollection   fileCollection   = pastaPrincipal.Files;


                                    foreach (var arquivo in fileCollection)
                                    {
                                        Pollux.Entities.AnexoProjeto anexoProjeto = new Pollux.Entities.AnexoProjeto();

                                        anexoProjeto.NomeArquivo    = arquivo.Name;
                                        anexoProjeto.DataArquivo    = arquivo.TimeCreated;
                                        anexoProjeto.UsuarioArquivo = anexo.ModificadoPor.Name;
                                        anexoProjeto.URL            = ObterUrlArquivo(urlSite, arquivo.ServerRelativeUrl);

                                        projetoItem.ListaAnexosProjeto.Add(anexoProjeto);
                                    }
                                }
                            }
                        }
                        catch
                        {
                            continue;
                        }
                    }
                }
                List <DocumentoSharePoint> lstAnexosClientePotencial = new Servicos.SharePointSiteService(this.Organizacao, this.IsOffline).ListarPorIdRegistro(clientePotencialConsulta.ID.Value);

                foreach (DocumentoSharePoint anexo in lstAnexosClientePotencial)
                {
                    try
                    {
                        string urlSite         = ConfigurationManager.GetSettingValue("UrlSiteSharePoint");
                        string urlFolderDetail = "";
                        if (!string.IsNullOrEmpty(anexo.UrlAbsoluta))
                        {
                            urlFolderDetail = anexo.UrlAbsoluta;
                        }
                        else if (!string.IsNullOrEmpty(anexo.UrlRelativa))
                        {
                            urlFolderDetail = urlSite + "/lead/" + anexo.UrlRelativa;
                        }
                        using (ClientContext spClientContext = new ClientContext(urlSite))
                        {
                            spClientContext.Credentials = new NetworkCredential(usuarioSharePoint, senhaSharePoint, domain);
                            var rootWeb = spClientContext.Web;

                            Folder pastaPrincipal = rootWeb.GetFolderByServerRelativeUrl(urlFolderDetail);

                            spClientContext.Load(pastaPrincipal, fs => fs.Files, p => p.Folders);
                            spClientContext.ExecuteQuery();
                            FolderCollection folderCollection = pastaPrincipal.Folders;
                            FileCollection   fileCollection   = pastaPrincipal.Files;

                            foreach (var arquivo in fileCollection)
                            {
                                Pollux.Entities.AnexoProjeto anexoProjeto = new Pollux.Entities.AnexoProjeto();

                                anexoProjeto.NomeArquivo    = arquivo.Name;
                                anexoProjeto.DataArquivo    = arquivo.TimeLastModified;
                                anexoProjeto.UsuarioArquivo = anexo.ModificadoPor.Name;
                                anexoProjeto.URL            = ObterUrlArquivo(urlSite, arquivo.ServerRelativeUrl);

                                projetoItem.ListaAnexosProjeto.Add(anexoProjeto);
                            }
                        }
                    }
                    catch
                    {
                        continue;
                    }
                }
                #endregion

                #region Produtos Projeto

                projetoItem.ListaProdutosProjeto = new List <Pollux.Entities.ProdutoProjeto>();
                List <ProdutoProjeto> lstProdutosClientePotencial = new Servicos.ProdutoProjetoService(this.Organizacao, this.IsOffline).ListarPorClientePotencial(clientePotencialConsulta.Id);

                if (lstProdutosClientePotencial.Count > 0)
                {
                    foreach (ProdutoProjeto produtoCliente in lstProdutosClientePotencial)
                    {
                        Pollux.Entities.ProdutoProjeto produtoProjeto = new Pollux.Entities.ProdutoProjeto();
                        var produto = new Servicos.ProdutoService(this.Organizacao, this.IsOffline).ObterPor(produtoCliente.Produto.Id);

                        produtoProjeto.CodigoProdutoClientePotencial = produtoCliente.Id.ToString();
                        produtoProjeto.CodigoProduto    = produto.Codigo;
                        produtoProjeto.DescricaoProduto = produto.Nome;
                        produtoProjeto.Quantidade       = produtoCliente.Quantidade;
                        produtoProjeto.PrecoUnitario    = produtoCliente.ValorUnitario;
                        produtoProjeto.ValorTotal       = produtoCliente.ValorTotal;

                        projetoItem.ListaProdutosProjeto.Add(produtoProjeto);
                    }
                }

                #endregion

                if (!resultadoPersistencia.Sucesso)
                {
                    retorno.Add("Resultado", resultadoPersistencia);
                    return(CriarMensagemRetorno <Pollux.MSG0269R1>(numeroMensagem, retorno));
                }

                resultadoPersistencia.Sucesso  = true;
                resultadoPersistencia.Mensagem = "Integração ocorrida com sucesso!";
                retorno.Add("ProjetoItem", projetoItem);
                retorno.Add("Resultado", resultadoPersistencia);

                return(CriarMensagemRetorno <Pollux.MSG0269R1>(numeroMensagem, retorno));
            }
            catch (Exception e)
            {
                resultadoPersistencia.Sucesso  = false;
                resultadoPersistencia.Mensagem = SDKore.Helper.Error.Handler(e);
                retorno.Add("Resultado", resultadoPersistencia);
                return(CriarMensagemRetorno <Pollux.MSG0269R1>(numeroMensagem, retorno));
            }
        }
示例#29
0
        public void EnviaEmailRegistroProjeto(ClientePotencial clientepotencial, bool duplicado)
        {
            //Envia e-mail e salva como tarefa no CRM
            try
            {
                Email email = new Email(OrganizationName, IsOffline);
                email.ReferenteAId   = clientepotencial.Id;
                email.ReferenteAType = "lead";
                email.ReferenteAName = clientepotencial.NomeDaEmpresa;
                email.ReferenteA     = new Lookup(clientepotencial.Id, clientepotencial.NomeDaEmpresa, "lead");
                email.Assunto        = "Projeto " + clientepotencial.NumeroProjeto + " enviado";
                if (duplicado)
                {
                    string corpoEmail = @"<style type=""text/css""> pre.mscrmpretag {  font-family: Tahoma, Verdana, Arial; style=""word-wrap: break-word;"" }</style>
                    <FONT size=2 face=Calibri>Prezado(a), <br /><br />
                    No sistema já há um registro para esse cliente final, sua solicitação será avaliada e em breve terá um retorno.
                    <br /><br />Pedimos que aguarde 48hs para receber o parecer se o projeto foi aceito ou não.
                    <br /><br />Registro de Projetos<br /><br />Soluções e Projetos<br /><br />intelbras.com.br</FONT>";
                    email.Mensagem = corpoEmail;
                }
                else
                {
                    string corpoEmail = @"<style type=""text/css""> pre.mscrmpretag {  font-family: Tahoma, Verdana, Arial; style=""word-wrap: break-word;"" }</style>
                    <FONT size=2 face=Calibri>Prezado(a), <br /><br />
                    Sua solicitação foi enviada com sucesso para área de Registro de Projetos.
                    <br /><br />Pedimos que aguarde 48hs para receber o parecer se o projeto foi aceito ou não.
                    <br /><br />Registro de Projetos<br /><br />Soluções e Projetos<br /><br />intelbras.com.br</FONT>";
                    email.Mensagem = corpoEmail;
                }
                email.De = new Lookup[] { new Lookup(new Guid(SDKore.Configuration.ConfigurationManager.GetSettingValue("ID_EMAIL_CORPORATIVO")), "systemuser") };

                if (duplicado)
                {
                    email.Para    = new Lookup[4];
                    email.Para[0] = new Lookup {
                        Id = clientepotencial.RevendaIntegrador.Id, Type = "account"
                    };
                    email.Para[1] = new Lookup {
                        Id = clientepotencial.Distribuidor.Id, Type = "account"
                    };
                    email.Para[2] = new Lookup {
                        Id = clientepotencial.Executivo.Id, Type = "contact"
                    };
                    Usuario proprietario = new CRM2013.Domain.Servicos.RepositoryService().Usuario.BuscarProprietario("lead", "leadid", clientepotencial.Id);
                    if (proprietario != null)
                    {
                        email.Para[3] = new Lookup {
                            Id = proprietario.Id, Type = "systemuser"
                        };
                    }
                }
                else
                {
                    email.Para    = new Lookup[3];
                    email.Para[0] = new Lookup {
                        Id = clientepotencial.RevendaIntegrador.Id, Type = "account"
                    };
                    email.Para[1] = new Lookup {
                        Id = clientepotencial.Distribuidor.Id, Type = "account"
                    };
                    email.Para[2] = new Lookup {
                        Id = clientepotencial.Executivo.Id, Type = "contact"
                    };
                }


                email.Direcao = false;
                email.ID      = (new CRM2013.Domain.Servicos.RepositoryService()).Email.Create(email);

                (new CRM2013.Domain.Servicos.RepositoryService()).Email.EnviarEmail(email.ID.Value);
            }
            catch (Exception ex)
            {
                SDKore.Helper.Log.Logar("emailprojetoduplicado.txt", ex.Message + ex.StackTrace);
            }
        }
示例#30
0
        public List <ProdutoProjeto> DefinirPropriedadesProdutos(Intelbras.Message.Helper.MSG0268 xml, ClientePotencial ClientePotencial)
        {
            List <ProdutoProjeto> lstRetorno = new List <ProdutoProjeto>();

            #region Lista ProdutoProjeto
            foreach (var item in xml.ListaProdutosProjeto)
            {
                //verificar se o vinculo existe criar ou editar

                ProdutoProjeto produtoProjeto = new ProdutoProjeto(this.Organizacao, this.IsOffline);
                if (!String.IsNullOrEmpty(item.CodigoProdutoClientePotencial))
                {
                    ProdutoProjeto produtoProjetoTemp = new Servicos.RepositoryService().ProdutoProjeto.Retrieve(new Guid(item.CodigoProdutoClientePotencial)); //new Servicos.ProdutoService(this.Organizacao, this.IsOffline).BuscaPorCodigo(item.CodigoProdutoClientePotencial);
                    if (produtoProjeto == null)
                    {
                        resultadoPersistencia.Sucesso  = false;
                        resultadoPersistencia.Mensagem = "Produto não cadastrado no Crm!";
                        return(null);
                    }

                    produtoProjeto = produtoProjetoTemp;
                }

                if (!String.IsNullOrEmpty(item.CodigoProduto))
                {
                    Product produto = new Servicos.ProdutoService(this.Organizacao, this.IsOffline).BuscaPorCodigo(item.CodigoProduto);
                    if (produto != null)
                    {
                        produtoProjeto.Produto = new Lookup(produto.ID.Value, "");
                    }
                    else
                    {
                        resultadoPersistencia.Sucesso  = false;
                        resultadoPersistencia.Mensagem = "Produto não cadastrado no Crm!";
                        return(null);
                    }
                }
                else
                {
                    resultadoPersistencia.Sucesso  = false;
                    resultadoPersistencia.Mensagem = "Codigo Produto não enviado.";
                    return(null);
                }

                produtoProjeto.ClientePotencial = new Lookup(ClientePotencial.ID.Value, "");
                produtoProjeto.ValorUnitario    = (item.PrecoUnitario == null) ? 0 : item.PrecoUnitario;
                produtoProjeto.Quantidade       = item.Quantidade;
                produtoProjeto.ValorTotal       = (item.ValorTotal == null) ? 0 : item.ValorTotal;

                lstRetorno.Add(produtoProjeto);
            }
            #endregion

            return(lstRetorno);
        }