/// <inheritdoc />
        public override Trigger Clone()
        {
            PeriodicTrigger clone = new PeriodicTrigger(startTimeUtc, endTimeUtc, period, jobExecutionCountRemaining);

            clone.nextFireTimeUtc  = nextFireTimeUtc;
            clone.misfireThreshold = misfireThreshold;
            clone.misfireAction    = misfireAction;
            clone.isFirstTime      = isFirstTime;

            return(clone);
        }
Esempio n. 2
0
        public IList<RisultatoInvioMessaggio> InvioMessaggio(int idAzienda, PersonaMessaggioDTO personaMessaggioDTO, Condominio condominio, int? idUnitaImmobiliare, int? idFornitore, int? idResponsabile, int? idIncaricatoAttivita, MotivoMessaggio motivoMessaggio, string oggetto, string testo, IList<string> destinatari, string mittente, string emailRapportino, IList<DocumentInfo> allegati, ParametriInvioLettera parametriInvioLettera)
        {
            // =========================================================
            //  Disabilito l'invio asincrono per problemi di gestione con Sertea
            //  diversi messaggi non sono stati inviati bugid#3823
            // =========================================================
            parametriInvioLettera.Asincrono = false;

            var message = string.Empty;
            var invioRiuscito = false;
            Persona persona = null;
            if(personaMessaggioDTO != null)
                persona = _daoFactory.GetPersonaDao().Find(personaMessaggioDTO.ID, false);

            _persona = persona;
            _condominio = condominio;
            _motivoMessaggio = motivoMessaggio;
            _oggetto = oggetto;
            _testo = testo;
            _destinatari = destinatari;
            _mittente = mittente;
            _emailRapportino = emailRapportino;

            var results = new List<RisultatoInvioMessaggio>();
            var result = new eMessageResultSendSMS();
            try
            {
                var destinatariSend = new List<string>();
                if (destinatari.Count > 0 && !destinatari.All(string.IsNullOrEmpty))
                {
                    foreach (var item in destinatari)
                    {
                        if (!string.IsNullOrEmpty(item))
                        {
                            if (!item.Trim().StartsWith("+39"))
                                destinatariSend.Add("+39" + Library.Conversione.ToPhoneNumber(item));
                            else
                                destinatariSend.Add(Library.Conversione.ToPhoneNumber(item));
                        }
                    }

                    if (destinatariSend.Any())
                    {
                        // =====================================
                        // Applico la stampa unione
                        // =====================================
                        if (personaMessaggioDTO != null)
                        {
                            int? idCondominio = null;
                            if (condominio != null)
                                idCondominio = condominio.ID;

                            var parametri = new ParametriStampaUnione(persona.ID, idUnitaImmobiliare, idResponsabile, idIncaricatoAttivita, idFornitore, idCondominio, null, personaMessaggioDTO.TipoIndirizzo, personaMessaggioDTO.Importo, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null);
                            oggetto = _messagisticaService.ApplicaStampaUnione(oggetto, parametri, idAzienda);
                            testo = _messagisticaService.ApplicaStampaUnione(testo, parametri, idAzienda);
                        }

                        // =====================================
                        // Invio Messaggio
                        // =====================================
                        var credenziali = _configurationService.GetLoginInfo(idAzienda);

                        if (credenziali != null && !string.IsNullOrEmpty(credenziali.Value.Utente) && !string.IsNullOrEmpty(credenziali.Value.Password))
                        {
                            var userService = new it.emessage.users.Users();
                            var success = false;
                            try
                            {
                                var resultUsers = userService.Login(credenziali.Value.Utente, credenziali.Value.Password, null);
                                success = resultUsers.success;
                            }
                            catch (Exception ex)
                            {
                                _log.WarnFormat("Errore durante il controllo delle credenziali - {0} - username:{1} - password:{2} - azienda:{3}", ex, Library.Utility.GetMethodDescription(), credenziali.Value.Utente, credenziali.Value.Password, idAzienda);
                            }

                            if (success)
                            {
                                var service = new Sms {Timeout = 999999999};
                                var identificazioneMittente = _configurationService.GetIdentificazioneMittente(idAzienda, TipoMessaggio.Sms, TipoIndirizzo.Recapito);
                                if (!string.IsNullOrEmpty(identificazioneMittente.Email))
                                    emailRapportino += "," + identificazioneMittente.Email;

                                // Mittente
                                if (string.IsNullOrEmpty(mittente))
                                    mittente = identificazioneMittente.Nome;
                                if (!string.IsNullOrEmpty(mittente) && mittente.Length > 11)
                                    mittente = mittente.Substring(0, 11);

                                if (ConfigurationManager.AppSettings["IsTest"] != null && bool.Parse(ConfigurationManager.AppSettings["IsTest"]))
                                    destinatariSend = new List<string> {"+393382958239"};

                                var parameters = new List<OptionalParameters>
                                {
                                    new OptionalParameters
                                    {
                                        ParameterName = "NotificationEmail",
                                        ParameterValue = emailRapportino
                                    },
                                    new OptionalParameters
                                    {
                                        ParameterName = "DeliveryTime",
                                        ParameterValue = DateTime.Now.ToString()
                                    }
                                };

                                // ---------------------------------------
                                //  Invio NON Asincrono
                                // ---------------------------------------
                                if (!parametriInvioLettera.Asincrono)
                                {
                                    if (motivoMessaggio != MotivoMessaggio.ScadenzaContratto)
                                    {
                                        try
                                        {
                                            if (string.IsNullOrEmpty(parametriInvioLettera.Tipo))
                                                parametriInvioLettera.Tipo = "NORMAL";
                                            result = service.Send(credenziali.Value.Utente, credenziali.Value.Password, mittente, destinatariSend.ToArray(), testo, parametriInvioLettera.Tipo, parameters.ToArray());
                                        }
                                        catch (Exception ex)
                                        {
                                            _log.FatalFormat("Errore inaspettato durante l'invio del sms - INVIO DIRETTO - {0} - oggetto:{1} - destinatari:{2} - testo:{3} - azienda:{4} - tipo:{5} - parameters:{6} - mittente:{7} - utente:{8}", ex, Library.Utility.GetMethodDescription(), oggetto, destinatariSend.Aggregate(string.Empty, (current, dest) => current + (dest + ", ")), testo, idAzienda, parametriInvioLettera.Tipo, parameters.Aggregate(string.Empty, (current, param) => current + (param + ", ")), mittente, credenziali.Value.Utente);
                                            throw;
                                        }
                                    }

                                    _log.InfoFormat("Risultato invio sms:{0} - destinatario:{1} - azienda:{2}", result, destinatariSend.Aggregate(string.Empty, (current, dest) => current + (dest + ", ")), idAzienda);

                                    if (result != null)
                                    {
                                        message += result;
                                        if (result.success)
                                            invioRiuscito = true;
                                    }
                                }

                                // ---------------------------------------
                                //  Invio Asincrono
                                // ---------------------------------------
                                else
                                {
                                    try
                                    {
                                        service.SendCompleted += serviceSendCompleted;
                                        service.SendAsync(credenziali.Value.Utente, credenziali.Value.Password, mittente, destinatariSend.ToArray(), testo, parametriInvioLettera.Tipo, parameters.ToArray());
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.FatalFormat("Errore inaspettato durante l'invio del sms - INVIO ASINCRONO - {0} - oggetto:{1} - destinatari:{2} - testo:{3} - azienda:{4} - tipo:{5} - parameters:{6} - mittente:{7} - utente:{8}", ex, Library.Utility.GetMethodDescription(), oggetto, destinatariSend.Aggregate(string.Empty, (current, dest) => current + (dest + ", ")), testo, idAzienda, parametriInvioLettera.Tipo, parameters.Aggregate(string.Empty, (current, param) => current + (param + ", ")), mittente, credenziali.Value.Utente);
                                        throw;
                                    }

                                    // Se invio asincrono suppongo sia andato a buon fine
                                    invioRiuscito = true;
                                    results.Add(new RisultatoInvioMessaggio("N.D.", "N.D.", true, "Tutti gli sms sono stati accodati per l'invio", new DocumentInfo()));
                                }

                                if (invioRiuscito)
                                {
                                    // =====================================
                                    // Controllo rapportino
                                    // =====================================
                                    if (parametriInvioLettera.Tipo == "NOTIFICATION")
                                    {
                                        // Crea un trigger che parte tra 10 minuti e ogni minuto per 30 volte controlla le mail in arrivo.
                                        Trigger trigger = new PeriodicTrigger(DateTime.UtcNow.AddSeconds(10), null, TimeSpan.FromMinutes(1), 30);

                                        var jobSpec = new JobSpec("Controllo rapportino", "Verifica e salvataggio email contenente rapportino di conferma di invio SMS", "ConfermaRicezioneMessaggio", trigger);
                                        _scheduler.CreateJob(jobSpec, CreateJobConflictAction.Replace);

                                        _scheduler.Start();
                                    }
                                }
                            }
                            else
                            {
                                _log.WarnFormat("Credenziali non valide - {0} - username:{1} - password:{2} - azienda:{3}", Library.Utility.GetMethodDescription(), credenziali.Value.Utente, credenziali.Value.Password, idAzienda);
                            }
                        }
                        else
                        {
                            _log.FatalFormat("Errore inaspettato durante l'invio del sms. NON sono presenti le credenziali per l'invio del sms - {0} - oggetto:{1} - destinatari:{2} - azienda:{3}", Library.Utility.GetMethodDescription(), oggetto, destinatari.Aggregate(string.Empty, (current, dest) => current + (dest + ", ")), idAzienda);
                            message = "KO - Non sono definite le credenziali per l'invio dei sms";
                        }
                    }
                    else
                    {
                        _log.WarnFormat("Errore inaspettato durante l'invio del sms. NON è definito nessun destinatario - {0} - oggetto:{1} - destinatari:{2} - azienda:{3}", Library.Utility.GetMethodDescription(), oggetto, destinatari.Aggregate(string.Empty, (current, dest) => current + (dest + ", ")), idAzienda);
                        message = "KO - Non è definito nessun destinatario";
                    }

                }
                else
                {
                    _log.WarnFormat("Errore inaspettato durante l'invio del sms. NON è definito nessun destinatario - {0} - oggetto:{1} - destinatari:{2} - azienda:{3}", Library.Utility.GetMethodDescription(), oggetto, destinatari.Aggregate(string.Empty, (current, dest) => current + (dest + ", ")), idAzienda);
                    message = "KO - Non è definito nessun destinatario";
                }
            }
            catch (Exception ex)
            {
                invioRiuscito = false;
                _log.ErrorFormat("Errore inaspettato durante l'invio del sms - {0} - oggetto:{1} - destinatari:{2} - azienda:{3}", ex, Library.Utility.GetMethodDescription(), oggetto, destinatari.Aggregate(string.Empty, (current, dest) => current + (dest + ", ")), idAzienda);
                message = "KO - Errore inaspettato durante l'invio del sms";
            }

            // ===================================================================
            //  Storicizzazione dei messaggi solo se l'invio non è stato asicrono
            // ===================================================================
            if (!parametriInvioLettera.Asincrono && motivoMessaggio != MotivoMessaggio.ScadenzaContratto && invioRiuscito)
            {
                results = elaboraResult(result, results);
            }
            else
            {
                if(!invioRiuscito)
                    results.Add(new RisultatoInvioMessaggio("KO", null, false, message, new DocumentInfo()));
            }

            return results;
        }
		/// <inheritdoc />
		public override Trigger Clone()
		{
			PeriodicTrigger clone = new PeriodicTrigger(startTimeUtc, endTimeUtc, period, jobExecutionCountRemaining);
			clone.nextFireTimeUtc = nextFireTimeUtc;
			clone.misfireThreshold = misfireThreshold;
			clone.misfireAction = misfireAction;
			clone.isFirstTime = isFirstTime;

			return clone;
		}
Esempio n. 4
0
        protected override void OnStart(string[] args)
        {
            try
            {
                _shSferaService.Open();
                _log.Info("Servizio Sfera Avviato");

                _shFileTranferServiceHost.Open();
                _log.Info("Servizio FileTransfer Avviato");

                _log.Info("Inizio caricamento cache");
                PreLoadedCollection.Instance.SetBanche();
                PreLoadedCollection.Instance.SetLocalita();
                _log.Info("Fine cache");

                IWindsorContainer container = new WindsorContainer();
                container.Kernel.Resolver.AddSubResolver(new ArrayResolver(container.Kernel, true));
                container.Kernel.Resolver.AddSubResolver(new ListResolver(container.Kernel, true));
                container.Install(Castle.Windsor.Installer.Configuration.FromAppConfig());

                // =====================================
                // Alert Contratti
                // =====================================
                // Crea un trigger che parte tra 10 minuti e ogni minuto per 30 volte controlla le mail in arrivo.
                Trigger trigger = new PeriodicTrigger(new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 23, 0, 0), null, TimeSpan.FromDays(1), null);

                // Create a job specification for my job.
                var jobSpec = new JobSpec("Alert Contratto", "Invio alert scadenza contratti e premi assicurativi", "AlertMessaggio", trigger);
                //jobSpec.JobData = jobData;

                // Create a job.  If it already exists in the persistent store then automatically update
                // its definition to reflect the provided job specification.  This is a good idea when using
                // a scheduler cluster because the job is guaranteed to be created exactly once and kept up
                // to date without it ever being accidentally deleted by one instance while another instance
                // is processing it.
                var scheduler = container.Resolve<IScheduler>();
                scheduler.CreateJob(jobSpec, CreateJobConflictAction.Replace);

                // Start the scheduler.
                scheduler.Start();

                // =====================================
                // Controllo Messaggi
                // =====================================
                // Crea un trigger che parte tra 15 minuti e controlla le info dei messaggi.
                Trigger triggerMessaggi = new PeriodicTrigger(DateTime.Now.AddHours(-2), null, TimeSpan.FromMinutes(15), null);

                // Create a job specification for my job.
                var jobSpecMessaggi = new JobSpec("Controllo Messaggi", "Controllo e aggiornamento info su messaggi inviati", "ControlloMessaggi", triggerMessaggi);
                var schedulerMessaggi = container.Resolve<IScheduler>();
                schedulerMessaggi.CreateJob(jobSpecMessaggi, CreateJobConflictAction.Replace);

                // Start the scheduler.
                schedulerMessaggi.Start();

                // =====================================
                // Controllo rapportino
                // =====================================
                // Crea un trigger che parte ogni 15 minuti controlla le mail in arrivo.
                Trigger triggerRapportino = new PeriodicTrigger(DateTime.Now.AddHours(-3), null, TimeSpan.FromMinutes(15), null);

                // Create a job specification for my job.
                var jobSpecRapportino = new JobSpec("Controllo rapportino", "Verifica e salvataggio email contenente rapportino di conferma di invio", "ConfermaRicezioneMessaggio", triggerRapportino);
                var schedulerRapportino = container.Resolve<IScheduler>();
                schedulerRapportino.CreateJob(jobSpecRapportino, CreateJobConflictAction.Replace);

                // Start the scheduler.
                schedulerRapportino.Start();

                // =====================================
                // Invio Mail
                // =====================================
                // Crea un trigger che parte subito e ogni minuto verifica e invia le mail presenti in coda.
                Trigger triggerMail = new PeriodicTrigger(DateTime.Now.AddHours(-1), null, TimeSpan.FromSeconds(int.Parse(ConfigurationManager.AppSettings["SendingMailDelay"])), null);

                // Create a job specification for my job.
                var jobSpecMail = new JobSpec("Invio Mail", "Invia le mail presenti nella coda di Delivery", "InvioMail", triggerMail);
                var schedulerMail = container.Resolve<IScheduler>();
                schedulerMail.CreateJob(jobSpecMail, CreateJobConflictAction.Replace);

                // Start the scheduler.
                schedulerMail.Start();

                // =====================================
                // Ricezione Documenti Fatture
                // =====================================
                // Crea un trigger che parte alle 02 di mattina per preparare il file contenente gli identificativi delle fatture da scaricare
                Trigger triggerRicezioneDocumentiFatture = new PeriodicTrigger(new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 01, 0, 0), null, TimeSpan.FromDays(1), null);

                // Create a job specification for my job.
                var jobRicezioneDocumentiFatture = new JobSpec("Ricezione Documenti Fatture", "Predispone il file per la ricezione dei documenti delle fatture", "RicezioneDocumentiFatture", triggerRicezioneDocumentiFatture);
                var schedulerRicezioneDocumentiFatture = container.Resolve<IScheduler>();
                schedulerRicezioneDocumentiFatture.CreateJob(jobRicezioneDocumentiFatture, CreateJobConflictAction.Replace);

                // Start the scheduler.
                schedulerRicezioneDocumentiFatture.Start();
            }
            catch (Exception ex)
            {
                _log.Error("Errore nell'avvio di SferaService:  OnStart(string[] args)", ex);
                throw;
            }
    }