Exemple #1
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;
        }
Exemple #2
0
        public IList<InfoSpedizioneMessaggioDTO> GetInfoMessaggio(int? idAzienda, IList<int> idMessaggi)
        {
            try
            {
                var result = new List<InfoSpedizioneMessaggioDTO>();
                var idAziende = new List<int>();
                if (idAzienda != null)
                    idAziende.Add(idAzienda.GetValueOrDefault());
                else
                {
                    var aziende = _daoFactory.GetAziendaDao().GetAll();
                    idAziende.AddRange(aziende.Select(azienda => azienda.ID));
                }

                var service = new it.emessage.reports.Reports { Timeout = 999999999 };
                var userService = new it.emessage.users.Users();
                foreach (var id in idAziende)
                {
                    try
                    {
                        var credenziali = _configurationService.GetLoginInfo(id);
                        if (credenziali != null && !string.IsNullOrEmpty(credenziali.Value.Utente) && !string.IsNullOrEmpty(credenziali.Value.Password))
                        {
                            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, Security.Login.Instance.CurrentLogin().Azienda);
                            }
                            if (success)
                            {
                                var date = getDataInizialeFinale(idMessaggi);
                                var dataIniziale = date[0];
                                var dataFinale = date[1];

                                var report = new it.emessage.reports.eMessageResultReportSms();
                                try
                                {
                                    report = service.GetSmsList(credenziali.Value.Utente, credenziali.Value.Password, dataIniziale, dataFinale, null);
                                }
                                catch (Exception ex)
                                {
                                    _log.ErrorFormat("Errore durante la lettura del report di invio degli sms - {0} - username:{1} - password:{2} - dataIniziale:{3} - dataFinale:{4} - azienda:{5}", ex, Library.Utility.GetMethodDescription(), credenziali.Value.Utente, credenziali.Value.Password, dataIniziale, dataFinale, id);
                                }

                                if (report != null && report.SmsList != null)
                                {
                                    foreach (var sms in report.SmsList)
                                    {
                                        try
                                        {
                                            var info = new InfoSpedizioneMessaggioDTO
                                            {
                                                CodiceMessaggio = sms.SmsCode,
                                                Costo = Convert.ToDecimal(sms.SmsCost),
                                                DataRicezione = sms.NotificationTime,
                                                Destinatario = new List<string> { sms.ParamTo },
                                                FineSpedizione = sms.JobFinished,
                                                InizioSpedizione = sms.JobInserted,
                                                Mittente = new List<string> { sms.ParamFrom },
                                                RisultatoSpedizione = sms.RetVal,
                                                StatoMessaggio = sms.NotificationStatus,
                                                TipoSpedizione = sms.Quality.ToString(),
                                                NumeroMessaggi = sms.NumberOfSms
                                            };

                                            if (idMessaggi != null && idMessaggi.Count > 0)
                                            {
                                                var messaggi = getMessaggi(idMessaggi);
                                                var messaggio = messaggi.FirstOrDefault(item => item.CodiceMessaggio == sms.SmsCode || item.CodiceInvio == sms.NotificationCode);
                                                if (messaggio != null)
                                                    info.Id = messaggio.ID;
                                            }
                                            else
                                            {
                                                if (!string.IsNullOrEmpty(sms.SmsCode) && !string.IsNullOrEmpty(sms.SmsCode.Trim()))
                                                {
                                                    var messaggi = _daoFactory.GetStoricoMessaggioDao().GetByCodiceMessaggio(sms.SmsCode);
                                                    if (!string.IsNullOrEmpty(sms.NotificationCode))
                                                    {
                                                        var messaggiByCodiceInvio = _daoFactory.GetStoricoMessaggioDao().GetByCodiceInvio(sms.NotificationCode);
                                                        foreach (var storicoMessaggio in messaggiByCodiceInvio)
                                                            messaggi.Add(storicoMessaggio);
                                                    }
                                                    foreach (var storicoMessaggio in messaggi)
                                                    {
                                                        storicoMessaggio.Costo = Convert.ToDecimal(sms.SmsCost);
                                                        storicoMessaggio.Quantita = sms.NumberOfSms;
                                                        storicoMessaggio.DataElaborazione = sms.JobFinished;
                                                        storicoMessaggio.DataRicezione = sms.NotificationTime;
                                                        if (!string.IsNullOrEmpty(sms.RetVal))
                                                        {
                                                            if (sms.RetVal.StartsWith("OK"))
                                                                storicoMessaggio.Stato = StatoMessaggio.Ricevuto;
                                                            else if (sms.RetVal.StartsWith("KO"))
                                                                storicoMessaggio.Stato = StatoMessaggio.Fallito;
                                                        }
                                                    }
                                                }
                                            }

                                            result.Add(info);

                                        }
                                        catch (Exception ex)
                                        {
                                            _log.ErrorFormat("Errore inaspettato durante il controllo dello stato del messaggio - SINGOLO MESSSAGGIO - {0} - smsCode:{1} - notificationCode:{2} - azienda:{3}", ex, Library.Utility.GetMethodDescription(), sms.SmsCode, sms.NotificationCode, id);
                                            throw;
                                        }
                                    }                                    
                                }

                            }
                            else
                            {
                                _log.WarnFormat("Credenziali non valide - {0} - username:{1} - password:{2} - azienda:{3}", Library.Utility.GetMethodDescription(), credenziali.Value.Utente, credenziali.Value.Password, Security.Login.Instance.CurrentLogin().Azienda);
                            }
                        }

                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato durante il controllo dello stato del messaggio - SINGOLA AZIENDA - {0} - azienda:{1}", ex, Library.Utility.GetMethodDescription(), id);
                        throw;
                    }
                }

                return result;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante il controllo dello stato del messaggio - {0}", ex, Library.Utility.GetMethodDescription());
                throw;
            }
        }