Example #1
0
        public string CierraTicketsResueltos()
        {
            StringBuilder        result = new StringBuilder();
            DataBaseModelContext db     = new DataBaseModelContext();

            try
            {
                result.AppendLine("Obteniendo parametros generales");
                ParametrosGenerales parametros = new BusinessParametros().ObtenerParametrosGenerales();
                if (parametros != null)
                {
                    if (parametros.DiasCierreTicket != null)
                    {
                        DateTime fecha = DateTime.Now.AddDays(-(double)parametros.DiasCierreTicket);
                        result.AppendLine(string.Format("Fecha aplicada {0} - {1}", fecha.ToLongDateString(), fecha.ToLongTimeString()));
                        var tickets = db.Ticket.Where(w => w.IdEstatusTicket == (int)BusinessVariables.EnumeradoresKiiniNet.EnumEstatusTicket.Resuelto && w.FechaTermino <= fecha);
                        result.AppendLine(string.Format("{0} Tickets encontrados", tickets.Count()));
                        foreach (Ticket ticket in tickets)
                        {
                            new BusinessAtencionTicket().CambiarEstatus(ticket.Id, (int)BusinessVariables.EnumeradoresKiiniNet.EnumEstatusTicket.Cerrado, ticket.IdUsuarioSolicito, "Cerrado por sistema");
                            result.AppendLine(string.Format("Cierre de ticket {0} correctamente", ticket.Id));
                        }
                    }
                }
            }
            catch (Exception e)
            {
                result.AppendLine(e.Message);
            }
            finally
            {
                db.Dispose();
            }
            return(result.ToString().Trim());
        }
Example #2
0
 protected override void OnStart(string[] args)
 {
     try
     {
         BusinessParametros  bparams    = new BusinessParametros();
         ParametrosGenerales parametros = bparams.ObtenerParametrosGenerales();
         double intervalo = 60000;
         if (parametros != null)
         {
             intervalo           = parametros.FrecuenciaDemonioSegundos * 1000;
             _intervaloEjecucion = new Timer(intervalo);
         }
         else
         {
             _intervaloEjecucion = new Timer(intervalo);
         }
         _intervaloEjecucion.Elapsed += intervaloEjecucion_Elapsed;
         _intervaloEjecucion.Start();
         LogCorrect("Timer Start");
     }
     catch (Exception ex)
     {
         LogError(ex.Message);
     }
 }
Example #3
0
        protected override void OnStart(string[] args)
        {
            //System.Diagnostics.Debugger.Launch();
            try
            {
                File.Create(AppDomain.CurrentDomain.BaseDirectory + "OnStart.txt");
                BusinessParametros  bparams    = new BusinessParametros();
                ParametrosGenerales parametros = bparams.ObtenerParametrosGenerales();
                double intervalo = 60000;
                if (parametros != null)
                {
                    intervalo           = parametros.FrecuenciaDemonioSegundos * 1000;
                    _intervaloEjecucion = new Timer(intervalo);
                }
                else
                {
                    _intervaloEjecucion = new Timer(intervalo);
                }

                _intervaloEjecucion.Elapsed += intervaloEjecucion_Elapsed;
                LogCorrect("KiiniNet", "Service Send Notication", "Iniciando Servicio");
                _intervaloEjecucion.Start();
                LogCorrect("KiiniNet", "Service Send Notication", "Servicio Iniciado");
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                LogError("KiiniNet", "Service Send Notication", ex.Message);
            }
        }
Example #4
0
        //TODO: Cambiar por parametro
        private int ObtenerDiasPeriodo()
        {
            int result = 7;
            ParametrosGenerales parameters = new BusinessParametros().ObtenerParametrosGenerales();

            if (parameters != null)
            {
                result = parameters.PeriodoDashboard;
            }
            return(result);
        }
Example #5
0
 public List <CorreoUsuario> ObtenerCorreosParametrosIdTipoUsuario(int idTipoUsuario, bool insertarSeleccion)
 {
     try
     {
         using (BusinessParametros negocio = new BusinessParametros())
         {
             return(negocio.ObtenerCorreosParametrosIdTipoUsuario(idTipoUsuario, insertarSeleccion));
         }
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Example #6
0
 public List <ParametrosTelefonos> TelefonosObligatorios(int idTipoUsuario)
 {
     try
     {
         using (BusinessParametros negocio = new BusinessParametros())
         {
             return(negocio.TelefonosObligatorios(idTipoUsuario));
         }
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Example #7
0
 public ParametrosUsuario ObtenerParametrosUsuario(int idTipoUsuario)
 {
     try
     {
         using (BusinessParametros negocio = new BusinessParametros())
         {
             return(negocio.ObtenerParametrosUsuario(idTipoUsuario));
         }
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Example #8
0
 public List <AliasUbicacion> ObtenerAliasUbicacion(int idTipoUsuario)
 {
     try
     {
         using (BusinessParametros negocio = new BusinessParametros())
         {
             return(negocio.ObtenerAliasUbicacion(idTipoUsuario));
         }
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Example #9
0
 public ParametrosGenerales ObtenerParametrosGenerales()
 {
     try
     {
         using (BusinessParametros negocio = new BusinessParametros())
         {
             return(negocio.ObtenerParametrosGenerales());
         }
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Example #10
0
 public List <ArchivosPermitidos> ObtenerArchivosPermitidos()
 {
     try
     {
         using (BusinessParametros negocio = new BusinessParametros())
         {
             return(negocio.ObtenerArchivosPermitidos());
         }
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Example #11
0
 public List <ColoresSla> ObtenerColoresSla()
 {
     try
     {
         using (BusinessParametros negocio = new BusinessParametros())
         {
             return(negocio.ObtenerColoresSla());
         }
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Example #12
0
 public List <FrecuenciaFecha> ObtenerFrecuenciasFecha()
 {
     try
     {
         using (BusinessParametros negocio = new BusinessParametros())
         {
             return(negocio.ObtenerFrecuenciasFecha());
         }
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Example #13
0
 public GraficosDefault ObtenerParametrosGraficoDefault(int idReporte)
 {
     try
     {
         using (BusinessParametros negocio = new BusinessParametros())
         {
             return(negocio.ObtenerParametrosGraficoDefault(idReporte));
         }
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Example #14
0
                public static MailMessage CreateReplyComentarioTicket(Mail source)
                {
                    MailMessage reply;

                    try
                    {
                        reply = new MailMessage()
                        {
                            From = new MailAddress(source.To[0].Address),
                        };
                        reply.To.Add(source.From.Address);
                        reply.ReplyToList.Add(source.From.Address);
                        //todo cambiar el correo al que se usa
                        string       respuesta  = source.TextBody.Split(new[] { "De: [email protected]" }, StringSplitOptions.None)[0];
                        Attachment[] attachment = source.Attachments;

                        string id = source.Headers.GetValueOfKey("Message-ID");
                        reply.Headers.Add("In-Reply-To", id);

                        string        references      = source.Headers.GetValueOfKey("References");
                        string[]      referencesArray = references.Split('~');
                        List <string> lstTickets      = referencesArray.Where(w => w.Contains("ticket")).Distinct().ToList();
                        if (lstTickets.Count > 1)
                        {
                            return(null);
                        }
                        string   stringTicket   = lstTickets.First();
                        string[] ticketContains = stringTicket.Split('&');

                        if (ticketContains.Count() <= 0)
                        {
                            return(null);
                        }

                        int idticket = int.Parse(ticketContains[1]);
                        if (idticket == 0)
                        {
                            return(null);
                        }
                        HelperDetalleTicket ticket = new BusinessTicket().ObtenerDetalleTicket(idticket);
                        //new BusinessSecurity.Autenticacion().GetUserInvitadoDataAutenticate((int)BusinessVariables.EnumTiposUsuario.Cliente);
                        Usuario user           = new BusinessUsuarios().ObtenerDetalleUsuario(ticket.IdUsuarioLevanto);
                        bool    eliminoarchivo = false;
                        if (attachment.Any())
                        {
                            string        attname;
                            List <string> archivos = new List <string>();
                            foreach (Attachment att in attachment)
                            {
                                string extension = Path.GetExtension(att.Name);
                                if (extension != null)
                                {
                                    ParametrosGenerales parametros = new BusinessParametros().ObtenerParametrosGenerales();
                                    double tamañoArchivo           = double.Parse(parametros.TamanoDeArchivo);
                                    List <ArchivosPermitidos> archivospermitidos = new BusinessParametros().ObtenerArchivosPermitidos();
                                    if (archivospermitidos.Any(a => a.Extensiones.Contains(extension)))
                                    {
                                        attname = String.Format("{0}_{1}_{2}{3}{4}{5}{6}{7}{8}", att.Name.Replace(extension, string.Empty), idticket, DateTime.Now.Day, DateTime.Now.Month, DateTime.Now.Year, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second, extension);
                                        att.SaveAs(String.Format("{0}{1}", ConfigurationManager.AppSettings["Repositorio"] + ConfigurationManager.AppSettings["RepositorioMascara"] + ConfigurationManager.AppSettings["CarpetaTemporal"], attname), true);

                                        if (File.Exists(String.Format("{0}{1}", ConfigurationManager.AppSettings["Repositorio"] + ConfigurationManager.AppSettings["RepositorioMascara"] + ConfigurationManager.AppSettings["CarpetaTemporal"], attname)))
                                        {
                                            long length = new FileInfo(String.Format("{0}{1}", ConfigurationManager.AppSettings["Repositorio"] + ConfigurationManager.AppSettings["RepositorioMascara"] + ConfigurationManager.AppSettings["CarpetaTemporal"], attname)).Length;

                                            if (((length / 1024) / 1024) <= tamañoArchivo)
                                            {
                                                archivos.Add(attname);
                                            }
                                            else
                                            {
                                                if (File.Exists(String.Format("{0}{1}", ConfigurationManager.AppSettings["Repositorio"] + ConfigurationManager.AppSettings["RepositorioMascara"] + ConfigurationManager.AppSettings["CarpetaTemporal"], attname)))
                                                {
                                                    File.Delete(String.Format("{0}{1}", ConfigurationManager.AppSettings["Repositorio"] + ConfigurationManager.AppSettings["RepositorioMascara"] + ConfigurationManager.AppSettings["CarpetaTemporal"], attname));
                                                }
                                                eliminoarchivo = true;
                                            }
                                        }
                                    }
                                    else
                                    {
                                        eliminoarchivo = true;
                                    }
                                }
                            }
                            new BusinessAtencionTicket().AgregarComentarioConversacionTicket(idticket, user.Id, respuesta, false, archivos, false, false);
                        }
                        else
                        {
                            new BusinessAtencionTicket().AgregarComentarioConversacionTicket(idticket, user.Id, respuesta, false, null, false, false);
                        }

                        if (string.IsNullOrEmpty(references))
                        {
                            references += "~ticket&" + idticket + "~";
                        }
                        if (!references.Contains("ticket&"))
                        {
                            references += "~ticket&" + idticket + "~";
                        }

                        reply.Headers.Add("References", references);

                        if (!source.Subject.StartsWith("Re:", StringComparison.OrdinalIgnoreCase))
                        {
                            reply.Subject = "Re: ";
                        }
                        reply.Subject += source.Subject;

                        reply.Subject    = reply.Subject.Replace("(Trial Version)", string.Empty).Trim();
                        reply.IsBodyHtml = true;
                        reply.Body       = GeneraRespuesta(source.From.Address, source.From.Address, source.HtmlBody, source.SentDate.ToString(CultureInfo.InvariantCulture), eliminoarchivo);
                    }
                    catch (Exception ex)
                    {
                        throw new Exception(ex.Message);
                    }
                    return(reply);
                }
Example #15
0
                private static List <HelperCampoMascaraCaptura> GeneraCaptura(Mascara mascara, string from, string subject, string contenido, Attachment[] atacchment, out string attname, out bool agregaArchivo, out bool eliminoarchivo)
                {
                    List <HelperCampoMascaraCaptura> result = new List <HelperCampoMascaraCaptura>();

                    try
                    {
                        Attachment att;
                        attname        = string.Empty;
                        agregaArchivo  = false;
                        eliminoarchivo = false;
                        foreach (CampoMascara campo in mascara.CampoMascara.OrderBy(o => o.Id))
                        {
                            switch (campo.NombreCampo.ToUpper())
                            {
                            case "NOMBRE":
                                result.Add(new HelperCampoMascaraCaptura
                                {
                                    IdCampo     = campo.Id,
                                    NombreCampo = campo.NombreCampo,
                                    Valor       = from
                                });
                                break;

                            case "CORREO":
                                result.Add(new HelperCampoMascaraCaptura
                                {
                                    IdCampo     = campo.Id,
                                    NombreCampo = campo.NombreCampo,
                                    Valor       = from
                                });
                                break;

                            case "ASUNTO":
                                result.Add(new HelperCampoMascaraCaptura
                                {
                                    IdCampo     = campo.Id,
                                    NombreCampo = campo.NombreCampo,
                                    Valor       = subject
                                });
                                break;

                            case "COMENTARIO":
                                result.Add(new HelperCampoMascaraCaptura
                                {
                                    IdCampo     = campo.Id,
                                    NombreCampo = campo.NombreCampo,
                                    Valor       = contenido
                                });
                                break;

                            case "ARCHIVOADJUNTO":
                                if (atacchment.Any())
                                {
                                    att = atacchment.First();
                                    string extension = Path.GetExtension(att.Name);

                                    if (extension != null)
                                    {
                                        ParametrosGenerales parametros = new BusinessParametros().ObtenerParametrosGenerales();
                                        double tamañoArchivo           = double.Parse(parametros.TamanoDeArchivo);
                                        List <ArchivosPermitidos> archivospermitidos = new BusinessParametros().ObtenerArchivosPermitidos();
                                        if (archivospermitidos.Any(a => a.Extensiones.Contains(extension)))
                                        {
                                            attname = String.Format("{0}_{1}_{2}{3}{4}{5}{6}{7}{8}", att.Name.Replace(extension, string.Empty), "ticketid", DateTime.Now.Day, DateTime.Now.Month, DateTime.Now.Year, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second, extension);
                                            att.SaveAs(String.Format("{0}{1}", ConfigurationManager.AppSettings["Repositorio"] + ConfigurationManager.AppSettings["CarpetaTemporal"], attname), true);
                                            long length = new FileInfo(String.Format("{0}{1}", ConfigurationManager.AppSettings["Repositorio"] + ConfigurationManager.AppSettings["CarpetaTemporal"], attname)).Length;

                                            if (((length / 1024) / 1024) <= tamañoArchivo)
                                            {
                                                result.Add(new HelperCampoMascaraCaptura
                                                {
                                                    IdCampo     = campo.Id,
                                                    NombreCampo = campo.NombreCampo,
                                                    Valor       = attname
                                                });
                                                eliminoarchivo = false;
                                                agregaArchivo  = true;
                                            }
                                            else
                                            {
                                                File.Delete(String.Format("{0}{1}", ConfigurationManager.AppSettings["Repositorio"] + ConfigurationManager.AppSettings["CarpetaTemporal"], attname));
                                                attname        = "";
                                                eliminoarchivo = true;
                                                agregaArchivo  = false;
                                            }
                                        }
                                        else
                                        {
                                            attname        = "";
                                            eliminoarchivo = true;
                                            agregaArchivo  = false;
                                        }
                                    }
                                }
                                else
                                {
                                    result.Add(new HelperCampoMascaraCaptura
                                    {
                                        IdCampo     = campo.Id,
                                        NombreCampo = campo.NombreCampo,
                                        Valor       = string.Empty
                                    });
                                }
                                break;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        throw new Exception(ex.Message);
                    }
                    return(result);
                }