public IList<RisultatoInvioMessaggio> NotificaAIncaricato(int idCondominio, AttivitaDTO attivita, IList<NameValueDTOOfintstring> contatti, string emailRapportino, string mittente, string oggettoMessaggio, string testoMessaggio, IList<DocumentoDTO> documenti, IList<DocumentInfo> allegatiNuovi, int? idModello, ParametriStampaUnione parametriCompilazioneLettera, ParametriInvioLettera parametriInvioLettera, TipoMessaggio tipo, bool aggiornaContatti)
{
// -----------------------------------------------
// Documenti Allegati
// -----------------------------------------------
var idDocumenti = new List<DocumentoMessaggioDTO>();
if (documenti != null)
{
idDocumenti.AddRange(documenti.Select(documento => new DocumentoMessaggioDTO {Id = documento.ID, IdSpesa = documento.IdSpesa}));
}
// -----------------------------------------------
// Destinatari
// -----------------------------------------------
var persone = new List<PersonaMessaggioDTO>();
var contattiPersona = contatti.GroupBy(item => item.Value);
foreach (var item in contattiPersona)
{
var persona = new PersonaMessaggioDTO();
var listaContatti = new List<ContattoDTO>();
foreach (var valoreContatto in item)
{
var contatto = new ContattoDTO
{
Valore = valoreContatto.Name,
TipoContatto = tipo.ToString(),
SelectColumn = true
};
listaContatti.Add(contatto);
}
persona.ID = item.Key;
persona.Contatti = listaContatti;
persona.OggettoMessaggio = oggettoMessaggio;
persona.TestoMessaggio = testoMessaggio;
persona.NomeMessaggio = $"MessaggioAttivita_{DateTime.Now.ToString("dd-mm-yyyy")}";
if (tipo == TipoMessaggio.Lettera)
persona.TipoIndirizzo = item.Any(contatto => contatto.Name == "Residenza")
? TipoIndirizzo.Residenza
: TipoIndirizzo.Recapito;
persone.Add(persona);
}
var idAttivita = 0;
if (attivita != null)
{
idAttivita = attivita.ID;
parametriCompilazioneLettera.Descrizione = attivita.Note;
}
var result = GetServiceClient().NotificaAIncaricato(idAttivita, MotivoMessaggio.NotificaAttivita, persone, oggettoMessaggio, testoMessaggio, mittente, emailRapportino, idDocumenti, new List<DocumentInfo>(allegatiNuovi), tipo, idModello, parametriCompilazioneLettera, parametriInvioLettera, aggiornaContatti, idCondominio, GetUserInfo());
CloseService();
// Apro eventuali documenti
if (parametriInvioLettera.Aggregazione == AggregazioneDocumentiEnum.DocumentoUnico)
_manageDocumentService.Open(result.MessaggioGenerato, null, true, MergeFieldType.Default);
else
{
foreach (var risultatoInvioMessaggio in result.RisultatoInvio)
{
if (risultatoInvioMessaggio.Messaggio.Body != null)
_manageDocumentService.Open(risultatoInvioMessaggio.Messaggio, null, true, MergeFieldType.Default);
}
}
return result.RisultatoInvio;
}
public DialogResult OpenDialogFormTestoMessaggioPersone(IList<PersonaContattoDTO> personeSelezionate, string contattoMittente, ParametriStampaUnione parametriLettera, string nomeFile, DocumentoFilter filterDocumenti, bool sceltaModello)
{
DialogResult result;
using (var form = new TestoMessaggioPersoneUI(personeSelezionate, contattoMittente, parametriLettera, sceltaModello, _manageDocumentService, _modelloLetteraService))
{
result = form.ShowDialog();
_modelloLettera = form.GetModelloLettera();
_emailRapportino = form.GetEmailRapportino();
_testoMessaggio = form.GetTestoMessaggio();
_oggettoMessaggio = form.GetOggetto();
_invioVeloce = form.GetInvioVeloce();
_messageType = form.GetMessageType();
_colore = form.GetColore();
_apriFile = form.GetApriFile();
_aggregazione = form.GetAggregazioneDocumenti();
_formatoDocumento = form.GetFormatoDocumento();
_accodaMessaggio = form.GetAccodaMessaggio();
_numeraPagine = form.GetNumeraPagine();
_fronteRetro = form.GetFronteRetro();
_primaPaginaMittente = form.GetPrimaPaginaMittente();
_mittente = form.GetMittente();
_tipoMessaggio = form.GetTipoMessaggio();
_documenti = form.GetDocumenti();
_documentiNew = form.GetDocumentiNew();
_personeSelezionate = form.GetPersoneSelezionate();
_parametriInvioLettera = new ParametriInvioLettera { Tipo = form.GetMessageType() };
_aggiornaContatti = false;
}
Application.DoEvents();
return result;
}
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)
{
if (destinatari.Count > 0)
{
var logDocuments = true;
var results = new List<RisultatoInvioMessaggio>();
var allegatiLista = new List<DocumentInfo>(allegati.Count + 1);
Persona persona = null;
if(personaMessaggioDTO != null)
persona = _daoFactory.GetPersonaDao().Find(personaMessaggioDTO.ID, false);
try
{
// =====================================
// Creo le pagine della Lettera
// =====================================
var nomiFiles = new string[allegati.Count];
var contenutoAllegati = new byte[allegati.Count][];
// -------------------------------------
// Allegati
// -------------------------------------
var index = 0;
foreach (var documento in allegati)
{
nomiFiles[index] = documento.FileName + documento.FileExtension;
contenutoAllegati[index] = _converter.ConvertToPdf(documento).ToArray();
allegatiLista.Add(documento);
index++;
}
// =====================================
// Invio Messaggio
// =====================================
// -------------------------------------
// Invio
// -------------------------------------
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}", ex, Library.Utility.GetMethodDescription(), credenziali.Value.Utente, credenziali.Value.Password);
}
if (success)
{
var tipoIndirizzo = TipoIndirizzo.Recapito;
if (personaMessaggioDTO != null)
tipoIndirizzo = personaMessaggioDTO.TipoIndirizzo;
var identificazioneMittente = _configurationService.GetIdentificazioneMittente(idAzienda, TipoMessaggio.Fax, tipoIndirizzo);
// Controllo identificazione mittente
if (string.IsNullOrEmpty(identificazioneMittente.Indirizzo))
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", null, false, "La lettera non può essere inviata perchè non è presente l'INDIRIZZO POSTALE del mittente" + Environment.NewLine + "Inserire l'informazione mancante nella anagrafica dello studio e riprovare.", new DocumentInfo()) };
if (string.IsNullOrEmpty(identificazioneMittente.Cap))
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", null, false, "La lettera non può essere inviata perchè non è presente il CAP del mittente" + Environment.NewLine + "Inserire l'informazione mancante nella anagrafica dello studio e riprovare.", new DocumentInfo()) };
if (string.IsNullOrEmpty(identificazioneMittente.Comune))
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", null, false, "La lettera non può essere inviata perchè non è presente il COMUNE del mittente" + Environment.NewLine + "Inserire l'informazione mancante nella anagrafica dello studio e riprovare.", new DocumentInfo()) };
if (string.IsNullOrEmpty(identificazioneMittente.Provincia))
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", null, false, "La lettera non può essere inviata perchè non è presente la PROVINCIA del mittente" + Environment.NewLine + "Inserire l'informazione mancante nella anagrafica dello studio e riprovare.", new DocumentInfo()) };
if (string.IsNullOrEmpty(identificazioneMittente.Stato))
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", null, false, "La lettera non può essere inviata perchè non è presente lo STATO del mittente" + Environment.NewLine + "Inserire l'informazione mancante nella anagrafica dello studio e riprovare.", new DocumentInfo()) };
// Controllo destinatari
foreach (var dest in destinatari)
{
var destinatarioAry = dest.Split('¥');
var recipient = new Contact
{
Company = destinatarioAry[0],
FirstName = destinatarioAry[1],
LastName = destinatarioAry[2],
Address = destinatarioAry[3],
City = destinatarioAry[4],
State = destinatarioAry[5],
ZipCode = destinatarioAry[6],
Country = destinatarioAry[7]
};
if (string.IsNullOrEmpty(recipient.Address))
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", null, false, string.Format("La lettera non può essere inviata perchè non è presente l'INDIRIZZO POSTALE di '{0} {1} {2}' {3} Inserire l'informazione mancante nella anagrafica del destinatario e riprovare.", recipient.Company, recipient.FirstName, recipient.LastName, Environment.NewLine), new DocumentInfo()) };
if (string.IsNullOrEmpty(recipient.ZipCode))
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", null, false, string.Format("La lettera non può essere inviata perchè non è presente il CAP di '{0} {1} {2}' {3} Inserire l'informazione mancante nella anagrafica del destinatario e riprovare.", recipient.Company, recipient.FirstName, recipient.LastName, Environment.NewLine), new DocumentInfo()) };
if (string.IsNullOrEmpty(recipient.City))
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", null, false, string.Format("La lettera non può essere inviata perchè non è presente il COMUNE di '{0} {1} {2}' {3} Inserire l'informazione mancante nella anagrafica del destinatario e riprovare.", recipient.Company, recipient.FirstName, recipient.LastName, Environment.NewLine), new DocumentInfo()) };
if (string.IsNullOrEmpty(recipient.State))
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", null, false, string.Format("La lettera non può essere inviata perchè non è presente la PROVINCIA di '{0} {1} {2}' {3} Inserire l'informazione mancante nella anagrafica del destinatario e riprovare.", recipient.Company, recipient.FirstName, recipient.LastName, Environment.NewLine), new DocumentInfo()) };
if (string.IsNullOrEmpty(recipient.Country))
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", null, false, string.Format("La lettera non può essere inviata perchè non è presente lo STATO di '{0} {1} {2}' {3} Inserire l'informazione mancante nella anagrafica del destinatario e riprovare.", recipient.Company, recipient.FirstName, recipient.LastName, Environment.NewLine), new DocumentInfo()) };
}
if (!string.IsNullOrEmpty(identificazioneMittente.Email))
{
if (!string.IsNullOrEmpty(emailRapportino))
emailRapportino += ",";
emailRapportino += identificazioneMittente.Email;
}
// Mittente
if (string.IsNullOrEmpty(mittente))
mittente = identificazioneMittente.Nome;
if (ConfigurationManager.AppSettings["IsTest"] != null && bool.Parse(ConfigurationManager.AppSettings["IsTest"]))
destinatari = new List<string> { "Giorgio Parmeggiani¥Giorgio¥Parmeggiani¥via Larga 36¥Bologna¥BO¥40138¥ITALIA" };
var sender = new Contact
{
Address = identificazioneMittente.Indirizzo,
City = identificazioneMittente.Comune,
Company = identificazioneMittente.RagioneSociale,
State = identificazioneMittente.Provincia,
FirstName = identificazioneMittente.Nome,
LastName = identificazioneMittente.Cognome,
ZipCode = identificazioneMittente.Cap,
Country = identificazioneMittente.Stato
};
var recipients = new Contact[destinatari.Count];
var indexRecipients = 0;
foreach (var dest in destinatari)
{
var destinatarioAry = dest.Split('¥');
var recipient = new Contact
{
Company = destinatarioAry[0],
FirstName = destinatarioAry[1],
LastName = destinatarioAry[2],
Address = destinatarioAry[3],
City = destinatarioAry[4],
State = destinatarioAry[5],
ZipCode = destinatarioAry[6],
Country = destinatarioAry[7]
};
recipients[indexRecipients] = recipient;
indexRecipients++;
}
// Parametri spedizione
var parameters = new OptionalParameters[4];
parameters[0] = new OptionalParameters { ParameterName = "NotificationEmail", ParameterValue = emailRapportino };
parameters[1] = new OptionalParameters { ParameterName = "ColourPrint", ParameterValue = parametriInvioLettera.Colore.ToString() };
parameters[2] = new OptionalParameters { ParameterName = "OnlyFrontPrint", ParameterValue = (!parametriInvioLettera.FronteRetro).ToString() };
parameters[3] = new OptionalParameters { ParameterName = "CreateFirstPage", ParameterValue = parametriInvioLettera.PaginaIniziale.ToString() };
var service = new Letter { Timeout = 999999999 };
eMessageResultSendLetter resultSend;
try
{
var directoryName = string.Empty;
if (logDocuments)
{
directoryName = $"{AppDomain.CurrentDomain.BaseDirectory}temp/{Guid.NewGuid()}";
if (!Directory.Exists(directoryName))
Directory.CreateDirectory(directoryName);
for (var i = 0; i < contenutoAllegati.Length; i++)
{
var nomeFile = $"{directoryName}/{i.ToString().PadLeft(3, '0')}_{nomiFiles[i]}";
using (var file = new FileStream(nomeFile, FileMode.Create, FileAccess.Write))
{
file.Write(contenutoAllegati[i], 0, contenutoAllegati[i].Length);
}
}
}
var pdfMerge = new PdfMerge();
var fileUnico = pdfMerge.Merge(contenutoAllegati, false);
var contentToSend = new byte[1][];
contentToSend[0] = fileUnico;
var nomiFilesToSend = new string[1];
nomiFilesToSend[0] = motivoMessaggio.ToString();
if (!string.IsNullOrEmpty(oggetto))
nomiFilesToSend[0] += $"_{oggetto.ToFileName()}";
if (string.IsNullOrEmpty(nomiFilesToSend[0]))
nomiFilesToSend[0] = "document";
nomiFilesToSend[0] += ".pdf";
if (logDocuments)
{
var nomeFileUnico = $"{directoryName}/{nomiFilesToSend[0]}";
using (var file = new FileStream(nomeFileUnico, FileMode.Create, FileAccess.Write))
{
file.Write(fileUnico, 0, fileUnico.Length);
}
}
if (ConfigurationManager.AppSettings["IsTest"] != null && bool.Parse(ConfigurationManager.AppSettings["IsTest"]))
resultSend = null;
else
resultSend = service.Send(credenziali.Value.Utente, credenziali.Value.Password, sender, recipients, parametriInvioLettera.Tipo, contentToSend, nomiFilesToSend, parameters);
}
catch (System.Web.Services.Protocols.SoapException ex)
{
return new[]{ new RisultatoInvioMessaggio(null, null, false, ex.Message, new DocumentInfo()) };
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nell'invio della lettera - {0}", ex, Library.Utility.GetMethodDescription());
throw;
}
if (resultSend != null)
{
foreach (var eMessageSpeditionResult in resultSend.SpeditionResult)
{
string messaggioInvio;
if (eMessageSpeditionResult.success)
{
messaggioInvio = string.Format("Lettera accodata per l'invio: {0}", eMessageSpeditionResult.jobCode);
_log.InfoFormat("Invio lettera RIUSCITO - {0} - messageCode: {1} - messaggio: {2} - jobcode: {3} - destinatario: {4}", Library.Utility.GetMethodDescription(), eMessageSpeditionResult.messageCode, eMessageSpeditionResult.errorDescription, eMessageSpeditionResult.jobCode, destinatari.Aggregate(string.Empty, (current, dest) => current + (dest + ";")));
}
else
{
messaggioInvio = "Invio della lettera non riuscito:" + Environment.NewLine + eMessageSpeditionResult.errorDescription;
_log.WarnFormat("Invio lettera FALLITO - {0} - messageCode: {1} - messaggio: {2} - jobcode: {3} - destinatario: {4}", Library.Utility.GetMethodDescription(), eMessageSpeditionResult.messageCode, eMessageSpeditionResult.errorDescription, eMessageSpeditionResult.jobCode, destinatari.Aggregate(string.Empty, (current, dest) => current + (dest + ";")));
}
var resultInvio = new RisultatoInvioMessaggio(eMessageSpeditionResult.jobCode, eMessageSpeditionResult.messageCode, eMessageSpeditionResult.success, messaggioInvio, new DocumentInfo());
var storicoMessaggio = _messaggisticaService.StoricizzaMessaggio(persona, condominio, resultInvio, motivoMessaggio, oggetto, testo, destinatari, mittente, emailRapportino, allegatiLista, TipoMessaggio.Lettera);
if (storicoMessaggio != null)
resultInvio.IdMessaggio = storicoMessaggio.ID;
results.Add(resultInvio);
}
}
}
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.ErrorFormat("Errore inaspettato durante l'invio della lettera. NON sono presenti le credenziali per l'invio della lettera - {0} - oggetto:{1} - destinatario:{2} - azienda:{3}", Library.Utility.GetMethodDescription(), oggetto, destinatari[0], idAzienda);
var message = string.Format("KO - Non sono definite le credenziali per l'invio della lettera.{0}Inserire le credenziali corrette nel pannello Messaggistica dell'anagrafica dello studio", Environment.NewLine);
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", string.Empty, false, message, new DocumentInfo()) };
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'invio della lettera - {0} - oggetto:{1} - destinatario:{2} - azienda:{3}", ex, Library.Utility.GetMethodDescription(), oggetto, destinatari[0], Security.Login.Instance.CurrentLogin().Azienda);
throw;
}
return results;
}
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", string.Empty, false, "Non è definito nessun destinatario", new DocumentInfo()) };
}
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;
}
public RisultatoInvioMessaggioAllegati InvioMessaggioPersone(MotivoMessaggio motivoMessaggio, string oggetto, string messaggio, IList<PersonaMessaggioDTO> persone, Dictionary<int, BindingList<ContattoDTO>> contatti, string mittente, string emailRapportino, IList<DocumentoMessaggioDTO> allegati, IList<DocumentInfo> allegatiNuovi, TipoMessaggio tipo, int? idModello, ParametriStampaUnione parametri, ParametriInvioLettera parametriInvioLettera, bool aggiornaContatti, int? idCondominio, int azienda)
{
try
{
var result = new List<RisultatoInvioMessaggio>();
var allegatiResult = new List<DocumentInfo>();
var messaggioInviato = new DocumentInfo();
if (persone.Count > 0)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var archiviazioneService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IArchiviazioneOtticaService>();
var converter = _windsorRepository.GetContainer(_info.Azienda).Resolve<IConverter>();
Condominio condominio = null;
if (idCondominio > 0)
condominio = daoFactory.GetCondominioDao().Find(idCondominio.GetValueOrDefault(), false);
IMessageService service = null;
switch (tipo)
{
case TipoMessaggio.Fax:
service = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMessageService>("messageservice.fax");
break;
case TipoMessaggio.Email:
service = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMessageService>("messageservice.email");
break;
case TipoMessaggio.Sms:
service = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMessageService>("messageservice.sms");
break;
case TipoMessaggio.Lettera:
service = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMessageService>("messageservice.lettera");
break;
case TipoMessaggio.Manuale:
service = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMessageService>("messageservice.manuale");
break;
}
var personaService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IPersonaService>();
ModelloLettera modello = null;
if (idModello != null)
modello = daoFactory.GetModelloLetteraDao().GetById(idModello.Value, false);
// =========================================================================================
// Allegati
// =========================================================================================
var allegatiMessaggio = new List<DocumentInfo>(allegati.Count() + 1);
var documentoRepository = new DocumentoRepository(_info, _windsorRepository);
foreach (var idDocumento in allegati)
{
Documento documento = null;
if(idDocumento.Id != null)
documento = daoFactory.GetDocumentoDao().Find(idDocumento.Id.Value, false);
if (documento != null)
{
var tipoDocumento = TipoDocumentoArchiviazione.Contratto;
if (documento.SpesaRiferimento != null)
tipoDocumento = TipoDocumentoArchiviazione.FatturaPassiva;
var docInfo = documentoRepository.GetDocumentInfo(idDocumento.Id.Value, tipoDocumento);
if (docInfo.Body != null)
{
allegatiMessaggio.Add(docInfo);
allegatiResult.Add(docInfo);
}
else
_log.ErrorFormat("Tentativo di allegare documento vuoto - {0} - documento:{1}", Utility.GetMethodDescription(), documento.ID);
}
else if(documento == null && idDocumento.IdSpesa != null)
{
var spesa = daoFactory.GetSpesaDao().Find(idDocumento.IdSpesa.Value, false);
var identificativoArchiviazione = archiviazioneService.GetIdentificativoArchiviazione(spesa, false);
var docInfo = documentoRepository.GetDocumentBody(identificativoArchiviazione, TipoDocumentoArchiviazione.FatturaPassiva);
if (docInfo.Body != null)
allegatiMessaggio.Add(docInfo);
else
_log.ErrorFormat("Tentativo di allegare documento vuoto - {0} - spesa:{1}", Utility.GetMethodDescription(), idDocumento.IdSpesa);
}
}
// =========================================================================================
// Allegati Nuovi
// =========================================================================================
var allegatiNuoviAry = allegatiNuovi.ToArray();
for (var i = 0; i < allegatiNuoviAry.Length; i++)
{
if (string.IsNullOrEmpty(allegatiNuoviAry[i].BodyText))
{
var allegatiElaborati = elaboraAllegato(allegatiNuoviAry[i], null, parametri, tipo, converter, azienda);
if (allegatiElaborati != null)
{
allegatiMessaggio.Add(allegatiElaborati.Value.AllegatoDaInviare);
allegatiResult.Add(allegatiElaborati.Value.AllegatoResult);
}
}
}
// =========================================================================================
// Non è presente nessuna stampa unione
// =========================================================================================
if ((modello == null || !modello.StampaUnione) && !isStampaUnione(oggetto, messaggio))
{
if (modello != null && (tipo == TipoMessaggio.Fax || tipo == TipoMessaggio.Lettera || tipo == TipoMessaggio.Manuale || tipo == TipoMessaggio.Email))
{
var modelloLetteraService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IModelloLetteraService>();
var documento = modelloLetteraService.GetLettera(idModello.Value);
documento.FileName = "Documento Allegato";
if (tipo != TipoMessaggio.Manuale)
{
var doc = new Document(new MemoryStream(documento.Body));
var pdfStream = new MemoryStream();
doc.Save(pdfStream, SaveFormat.Pdf);
documento.Body = pdfStream.ToArray();
documento.FileExtension = ".pdf";
}
allegatiMessaggio.Insert(0, documento);
allegatiResult.Add(documento);
}
IList<PersonaMessaggioDTO> personeMessaggio = new List<PersonaMessaggioDTO>();
foreach (var personaMessaggio in persone)
{
IList<ContattoDTO> contattiPersona = new List<ContattoDTO>();
if (contatti.ContainsKey(personaMessaggio.ID))
contattiPersona = contatti[personaMessaggio.ID];
personaMessaggio.Contatti = contattiPersona;
personeMessaggio.Add(personaMessaggio);
}
var destinatari = personaService.GetContattiSelezionatiByTipo(personeMessaggio, tipo);
if (destinatari.Count > 0)
{
if (service != null)
{
var risultatoInvio = service.InvioMessaggio(azienda, null, null, parametri.IdUnitaImmobiliare, parametri.IdFornitore, parametri.IdResponsabile, parametri.IdIncaricatoAttivita, motivoMessaggio, oggetto, messaggio, destinatari, mittente, emailRapportino, allegatiMessaggio, parametriInvioLettera).ToArray();
// In questo caso lo storico deve essere creato ora per ogni persona
foreach (var personaMessaggio in persone)
{
var persona = daoFactory.GetPersonaDao().Find(personaMessaggio.ID, false);
if (persona != null)
{
var storicoMessaggio = getMessaggisticaService().StoricizzaMessaggio(persona, condominio, risultatoInvio[0], motivoMessaggio, oggetto, messaggio, destinatari, mittente, emailRapportino, allegatiMessaggio, tipo);
if (storicoMessaggio != null)
{
for (var i = 0; i < risultatoInvio.Length; i++)
risultatoInvio[i].IdMessaggio = storicoMessaggio.ID;
}
}
}
if (parametriInvioLettera.AccodaMessaggio || parametriInvioLettera.ApriFileGenerato)
{
var zipFile = service.FinalizzaMessaggio(oggetto, parametriInvioLettera.AccodaMessaggio, azienda);
if (parametriInvioLettera.ApriFileGenerato)
messaggioInviato = zipFile;
}
result.AddRange(risultatoInvio);
}
}
else
result.Add(new RisultatoInvioMessaggio(string.Empty, null, false, "Non è presente nessun destinatario", new DocumentInfo()));
}
// =========================================================================================
// E' presente stampa unione con modello oppure direttamente nel testo
// =========================================================================================
else
{
Delivery delivery = null;
foreach (var personaMessaggio in persone)
{
var allegatiInvio = allegatiMessaggio.ToList();
var persona = daoFactory.GetPersonaDao().Find(personaMessaggio.ID, false);
if (persona != null)
{
var modelloLetteraService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IModelloLetteraService>();
parametri.IdPersonaAttiva = personaMessaggio.ID;
parametri.Importo = personaMessaggio.Importo;
parametri.IdUnitaImmobiliare = personaMessaggio.IdUnitaImmobiliare;
if (idCondominio != null)
parametri.IdCondominio = idCondominio.Value;
var faxDestinatario = string.Empty;
if (tipo == TipoMessaggio.Fax && contatti.ContainsKey(persona.ID) && contatti[persona.ID].Count > 0)
faxDestinatario = contatti[persona.ID].FirstOrDefault().Valore;
if (string.IsNullOrEmpty(faxDestinatario))
{
var contattiCollection = new ContattoCollection(persona.Contatti);
var contattoFax = contattiCollection.GetFirstContatto<Fax>();
if (contattoFax != null)
faxDestinatario = contattoFax.Valore;
}
parametri.FaxDestinatario = faxDestinatario;
// Se è definita una persona da contattare nella stampa unione deve essere usata quest'ultima
var idPersonaStampaUnione = persona.ID;
if (parametri.IdPersonaRichiedente != null)
idPersonaStampaUnione = parametri.IdPersonaRichiedente.GetValueOrDefault();
var parametriStampaUnione = new ParametriStampaUnione(idPersonaStampaUnione, parametri.IdUnitaImmobiliare, parametri.IdResponsabile, parametri.IdIncaricatoAttivita, parametri.IdFornitore, idCondominio, null, personaMessaggio.TipoIndirizzo, personaMessaggio.Importo, null, null, null, parametri.TelefonoDaContattare, null, null, null, null, null, parametri.IdPersonaRichiedente, null, null, parametri.Descrizione, null, null, null, null, null, null) { IdAssemblea = parametri.IdAssemblea };
var messaggioPrincipale = getMessaggisticaService().ApplicaStampaUnione(messaggio, parametriStampaUnione, _info.Azienda);
var oggettoPrincipale = getMessaggisticaService().ApplicaStampaUnione(oggetto, parametriStampaUnione, _info.Azienda);
parametri.Oggetto = oggettoPrincipale;
parametri.TipoIndirizzo = personaMessaggio.TipoIndirizzo;
// ------------------------------------------------------------------------
//allegatiInvio
//devo processare gli allegati nuovi che hanno bodytext non nullo
//questi doc possono avere tag di stampa unione per persona
// =========================================================================================
// Allegati Nuovi
// =========================================================================================
allegatiNuoviAry = allegatiNuovi.ToArray();
for (var i = 0; i < allegatiNuoviAry.Length; i++)
{
if (!string.IsNullOrEmpty(allegatiNuoviAry[i].BodyText))
{
var allegatiElaborati = elaboraAllegato(allegatiNuoviAry[i], persona, parametri, tipo, converter, azienda);
if (allegatiElaborati != null)
{
allegatiInvio.Insert(0, allegatiElaborati.Value.AllegatoDaInviare);
allegatiResult.Add(allegatiElaborati.Value.AllegatoResult);
}
}
}
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Modello allegato presente
// ------------------------------------------------------------------------
if (idModello != null)
{
var documentoStampaUnione = modelloLetteraService.GetLetteraCompilata(idModello.Value, parametri);
switch (tipo)
{
case TipoMessaggio.Fax:
case TipoMessaggio.Lettera:
case TipoMessaggio.Email:
case TipoMessaggio.Manuale:
// Se l'invio è manuale con generazione creazione un unico file PDF non deve essere creato un nuovo documento con il modello selezionato
var checkSumDocumento = string.Empty;
if(tipo != TipoMessaggio.Manuale || parametriInvioLettera.Aggregazione == AggregazioneDocumentiEnum.DocumentiSeparati)
{
var documentMessage = getDocumentService().SaveDocument(documentoStampaUnione.Body, documentoStampaUnione.FileName, ".rtf", null, _info.Azienda);
if(documentMessage.Documento != null)
checkSumDocumento = documentMessage.Documento.Checksum;
}
else if (documentoStampaUnione.Body != null)
checkSumDocumento = Utility.GetFileChecksum(documentoStampaUnione.Body);
if (!string.IsNullOrEmpty(checkSumDocumento))
{
var body = documentoStampaUnione.Body;
var fileExtension = documentoStampaUnione.FileExtension;
if (tipo != TipoMessaggio.Manuale)
{
var doc = new Document(new MemoryStream(documentoStampaUnione.Body));
var pdfStream = new MemoryStream();
doc.Save(pdfStream, SaveFormat.Pdf);
body = pdfStream.ToArray();
fileExtension = ".pdf";
}
var documento = new DocumentInfo { Body = body, FileId = checkSumDocumento, FileName = checkSumDocumento, FileExtension = fileExtension };
allegatiInvio.Insert(0, documento);
if (tipo != TipoMessaggio.Manuale || !parametriInvioLettera.ApriFileGenerato)
allegatiResult.Add(documento);
}
break;
}
}
IList<ContattoDTO> contattiPersona = new List<ContattoDTO>();
if (contatti.ContainsKey(personaMessaggio.ID))
contattiPersona = contatti[personaMessaggio.ID];
var personeMessaggio = new List<PersonaMessaggioDTO>(1) { new PersonaMessaggioDTO { ID = personaMessaggio.ID, Contatti = contattiPersona, } };
var destinatari = personaService.GetContattiSelezionatiByTipo(personeMessaggio, tipo);
if (service != null)
{
int? idDelivery = null;
if (delivery != null)
idDelivery = delivery.Id;
var resultMessage = service.InvioMessaggio(azienda, new PersonaMessaggioDTO {ID = persona.ID, IdDelivery = idDelivery}, condominio, parametri.IdUnitaImmobiliare, parametri.IdFornitore, parametri.IdResponsabile, parametri.IdIncaricatoAttivita, motivoMessaggio, oggettoPrincipale, messaggioPrincipale, destinatari, mittente, emailRapportino, allegatiInvio, parametriInvioLettera);
if (resultMessage.Count > 0)
{
delivery = daoFactory.GetDeliveryPoDao().Find(resultMessage[0].IdDelivery, false);
result.AddRange(resultMessage);
}
}
}
}
if (parametriInvioLettera.AccodaMessaggio || parametriInvioLettera.ApriFileGenerato)
{
var zipFile = service.FinalizzaMessaggio(oggetto, parametriInvioLettera.AccodaMessaggio, azienda);
if (parametriInvioLettera.ApriFileGenerato)
messaggioInviato = zipFile;
}
}
}
else
result.Add(new RisultatoInvioMessaggio(string.Empty, null, false, "Non è presente nessun destinatario", new DocumentInfo()));
// ========================================
// Aggiorno i contatti
// ========================================
if(aggiornaContatti)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
foreach (var kvp in contatti)
{
var persona = daoFactory.GetPersonaDao().Find(kvp.Key, false);
if(persona != null)
{
var contattoRepository = new ContattoRepository(persona, _info, _windsorRepository);
foreach (var contattoDTO in kvp.Value)
{
var contatto = persona.Contatti.FirstOrDefault(item => item.Valore == contattoDTO.Valore);
if (contatto != null)
contattoDTO.ID = contatto.ID;
contattoDTO.Stato = "U";
contattoRepository.ManageDomainEntity(contattoDTO, true);
}
}
}
}
return new RisultatoInvioMessaggioAllegati(result, allegatiResult, messaggioInviato);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante l'invio del messaggio - {0} - idAzienda:{1} - oggetto:{2}", ex, Utility.GetMethodDescription(), azienda, oggetto);
throw;
}
}
public ParametriInvioLettera GetParametriInvioLettera()
{
var parametri = new ParametriInvioLettera
{
Colore = colore.Checked,
FronteRetro = fronteRetro.Checked,
PaginaIniziale = primaPagina.Checked,
Asincrono = invioVeloce.Checked,
Aggregazione = GetAggregazioneDocumenti(),
FormatoDocumento = GetFormatoDocumento(),
AccodaMessaggio = accodaMessaggio.Checked,
ApriFileGenerato = apriFile.Checked,
RinumeraPagine = numeraPagine.Checked,
};
var tipo = string.Empty;
if (GetTipoMessaggio() != TipoMessaggio.Lettera && sottoTipoMessaggio.Value != null)
tipo = sottoTipoMessaggio.Value.ToString();
if (GetTipoMessaggio() == TipoMessaggio.Lettera)
tipo = tipoLettera.Value.ToString();
parametri.Tipo = tipo;
return parametri;
}
/// <summary>
/// Funzione per l'invio del messaggio email
/// </summary>
/// <param name="idAzienda">Identificativo dell'azienda</param>
/// <param name="personaMessaggioDTO">DTO contenente l'identificativo della persona alla quale il messaggio viene inviato e altre informazioni utili all'invio del messaggio</param>
/// <param name="condominio">Condominio a cui appartiene la persona destinataria del messaggio può non essere definito</param>
/// <param name="idUnitaImmobiliare">Identificativo dell'unità immobiliare</param>
/// <param name="idIncaricatoAttivita">Identificativo del soggetto incaricato allo svolgimento dell'attività</param>
/// <param name="motivoMessaggio">Indica il motivo che ha portato all'invio del messaggio (es: Sollecito)</param>
/// <param name="oggetto">Oggetto del messaggio</param>
/// <param name="testo">Testo del messaggio</param>
/// <param name="destinatari">Destinatari del messaggio</param>
/// <param name="mittente">Mittente del messaggio</param>
/// <param name="emailRapportino">Se presente è l'indirizzo email a cui saranno inviate eventuali risposte, altrimenti viene usato il mittente</param>
/// <param name="allegati">Eventuali allegati del messaggio</param>
/// <param name="parametriInvioLettera">Parametri er l'invio della lettera: Se tipo è <value>alert</value> il messaggio viene inviato creando un messaggio di tipo alert (solo outlook) - <value>Asincrono</value>: indica se deve essere eseguito un invio asincrono</param>
/// <param name="idFornitore">Identificativo del fornitore</param>
/// <param name="idResponsabile">Identificativo del responsabile dell'attività</param>
/// <returns>Restituisce una lista di: codice dell'invio, eventuali messaggi, il flag che indica se l'invio è riuscito e il corpo, sotto forma di array di byte, del messaggio in formato standard 'eml'</returns>
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)
{
var message = string.Empty;
var invioRiuscito = true;
// Impostazioni Azienda
var impostazioniAzienda = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(idAzienda) ?? new ImpostazioniAzienda(_daoFactory.GetAziendaDao().Find(idAzienda, false));
// Applico la stampa unione
Persona persona = null;
if(personaMessaggioDTO != null)
{
int? idCondominio = null;
if (condominio != null)
idCondominio = condominio.ID;
persona = _daoFactory.GetPersonaDao().GetById(personaMessaggioDTO.ID, false);
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 = _messaggisticaService.ApplicaStampaUnione(oggetto, parametri, idAzienda);
testo = _messaggisticaService.ApplicaStampaUnione(testo, parametri, idAzienda);
}
// Mittente
if (string.IsNullOrEmpty(mittente))
{
var identificazioneMittente = _configurationService.GetIdentificazioneMittente(idAzienda, TipoMessaggio.Email, TipoIndirizzo.Recapito);
mittente = identificazioneMittente.Nome;
}
if (string.IsNullOrEmpty(mittente) && !string.IsNullOrEmpty(emailRapportino))
mittente = emailRapportino;
else if (string.IsNullOrEmpty(mittente))
message = "Non è possibile inviare un messaggio senza aver definito il mittente";
var fullPathFile = string.Empty;
var messaggio = new DocumentInfo();
// ========================================================
// Crezione del mail message solo se NON si tratta di messaggi automatici
// ========================================================
var referenceId = Guid.NewGuid().ToString();
if (motivoMessaggio != MotivoMessaggio.ScadenzaContratto &&
motivoMessaggio != MotivoMessaggio.NotificaResponsabileAttivita)
{
var mailMessage = new MailMessage();
if (string.IsNullOrEmpty(message) && !string.IsNullOrEmpty(mittente))
{
try
{
mailMessage.From = new MailAddress(mittente);
}
catch (Exception ex)
{
invioRiuscito = false;
message = "Mittente errato: " + mittente;
_log.ErrorFormat("Errore inaspettato durante l'invio della mail - IMPOSTAZIONE MITTENTE - {0} - mittente:{1} - oggetto:{2} - destinatario:{3}", ex, Utility.GetMethodDescription(), mittente, oggetto, destinatari[0]);
}
if (invioRiuscito)
{
foreach (var destinatario in destinatari.Distinct())
{
try
{
if (!string.IsNullOrEmpty(destinatario))
{
if (!destinatario.Trim().Contains(" "))
{
// Se il destinatario è uno solo uso il campo 'To' se invece è più di uno uso l'undisclosed recipient per evitare di
// avere in chiaro tutti i destinatari dei messaggi
if (ConfigurationManager.AppSettings["IsTest"] != null && bool.Parse(ConfigurationManager.AppSettings["IsTest"]))
{
if (destinatari.Count > 1)
mailMessage.Bcc.Add("*****@*****.**");
else
mailMessage.To.Add("*****@*****.**");
}
else
{
if (destinatari.Count > 1)
mailMessage.Bcc.Add(destinatario.Trim());
else
mailMessage.To.Add(destinatario.Trim());
}
}
else
{
invioRiuscito = false;
message = "L'email del destinatario non può contenere spazi: " + destinatario;
_log.WarnFormat("Errore inaspettato durante l'invio della mail - EMAIL DESTINATARIO CON SPAZI - {0} - destinatario:{1} - mittente:{2} - oggetto:{3}", Utility.GetMethodDescription(), destinatario, mittente, oggetto);
}
}
}
catch (Exception ex)
{
invioRiuscito = false;
message = "Destinatario errato: " + destinatario;
_log.WarnFormat("Errore inaspettato durante l'invio della mail - IMPOSTAZIONE DESTINATARIO - {0} - destinatario:{1} - mittente:{2} - oggetto:{3}", ex, Utility.GetMethodDescription(), destinatario, mittente, oggetto);
}
}
if (mailMessage.To.Count == 0 && mailMessage.Bcc.Count == 0)
{
invioRiuscito = false;
message = persona == null
? "Non sono presenti destinatari validi."
: $"Non sono presenti destinatari validi: {persona.DisplayName}";
_log.WarnFormat("Errore inaspettato durante l'invio della mail - {0} - {1} - mittente:{2} - oggetto:{3}", message.ToUpper(), Utility.GetMethodDescription(), mittente, oggetto);
}
if (invioRiuscito)
{
mailMessage.Subject = oggetto;
mailMessage.Body = testo;
if (testo.Contains('<') && testo.Contains('>'))
mailMessage.IsBodyHtml = true;
// Trucco per ottenere un messaggio di tipo "Alert" per outlook
if (parametriInvioLettera.Tipo == "alert")
mailMessage.Headers.Add("message-id", "<3BD50098E401463AA228377848493927-1>");
if (allegati != null)
{
foreach (var documento in allegati)
{
if (documento.Body != null)
{
var fileExtension = documento.FileExtension;
if (string.IsNullOrEmpty(fileExtension))
{
var extension = _fileTypeDetector.GetFileExtension(new MemoryStream(documento.Body));
if (!string.IsNullOrEmpty(extension))
fileExtension = $".{extension}".ToLower();
}
if (!string.IsNullOrEmpty(fileExtension))
{
string mimeType;
var mimeTypeList = _daoFactory.GetMimeTypeDao().GetByExtension(fileExtension);
if (mimeTypeList.Count > 0)
{
mimeType = mimeTypeList[0].Tipo;
// add the attachment from a stream
var memStream = new MemoryStream(documento.Body);
var streamWriter = new StreamWriter(memStream);
streamWriter.Flush();
// this is quite important
memStream.Position = 0;
var ct = new ContentType(mimeType)
{
Name = documento.FileName + fileExtension
};
var attachment = new Attachment(memStream, ct);
mailMessage.Attachments.Add(attachment);
}
else
{
_log.ErrorFormat("Il documento allegato non è stato riconosciuto - {0} - documento:{1} - fileName:{2} - extension:{3}", Utility.GetMethodDescription(), documento.FileId, documento.FileName, fileExtension);
}
}
}
else
{
_log.WarnFormat("ATTENZIONE: Tentativo di allegare un documento vuoto - {0} - documento:{1} - azienda:{2}", Utility.GetMethodDescription(), documento.FileId, idAzienda);
}
}
}
if (motivoMessaggio != MotivoMessaggio.ScadenzaContratto && motivoMessaggio != MotivoMessaggio.NotificaResponsabileAttivita)
{
try
{
mailMessage.DeliveryNotificationOptions = DeliveryNotificationOptions.OnSuccess | DeliveryNotificationOptions.OnFailure;
string destinatarioRicevuta;
switch (impostazioniAzienda.ControlloRapportinoMessaggistica)
{
case ControlloRapportino.Mittente:
destinatarioRicevuta = mittente;
break;
case ControlloRapportino.Automatico:
destinatarioRicevuta = "*****@*****.**";
break;
case ControlloRapportino.IndirizzoSpecifico:
destinatarioRicevuta = impostazioniAzienda.EmailControlloRapportinoMessaggistica;
break;
default:
destinatarioRicevuta = mittente;
break;
}
mailMessage.Headers.Add("Return-Receipt-To", destinatarioRicevuta);
mailMessage.Headers.Add("Disposition-Notification-To", destinatarioRicevuta);
mailMessage.Headers.Add("X-Confirm-Reading-To", destinatarioRicevuta);
// ========================================================
// Salvare il messaggio in formato .eml
// ========================================================
var emailStream = new MemoryStream();
mailMessage.MessageId = referenceId;
mailMessage.Save(emailStream, MessageFormat.Eml);
messaggio.Body = emailStream.ToArray();
messaggio.FileName = $"Email_{DateTime.Now.ToString("dd-mm-yyyy")}.eml";
messaggio.FileExtension = ".eml";
// Aggiungo la mail generata alla lista degli allegati
// ----------------------------------------------------
var documentMessage = _documentService.SaveDocument(messaggio.Body, messaggio.FileName, messaggio.FileExtension, null, idAzienda);
if (documentMessage.Documento != null)
{
fullPathFile = documentMessage.FilePath;
var checksum = documentMessage.Documento.Checksum;
messaggio.FileId = checksum;
if (allegati == null)
allegati = new List<DocumentInfo>();
allegati.Add(messaggio);
}
}
catch (Exception ex)
{
invioRiuscito = false;
message = "Si sono verificati problemi nel salvataggio del file EML :" + Environment.NewLine + ex.Message;
_log.FatalFormat("Errore inaspettato durante il salvataggio del file eml - {0} - oggetto:{1} - destinatario:{2}", ex, Utility.GetMethodDescription(), oggetto, destinatari.Aggregate("<NESSUNO>", (current, dest) => current + (dest + ", ")));
}
}
}
}
}
else
invioRiuscito = false;
}
// ========================================================
// Invio del messaggio
// ========================================================
Delivery delivery = null;
if (invioRiuscito)
{
try
{
var deliveryMessages = new List<DeliveryMessage>(destinatari.Count);
if (motivoMessaggio == MotivoMessaggio.ScadenzaContratto || motivoMessaggio == MotivoMessaggio.NotificaResponsabileAttivita)
{
foreach (var destinatario in destinatari)
{
var deliveryMessage = new DeliveryMessage(new System.Net.Mail.MailAddress(destinatario, destinatario), oggetto, testo, referenceId);
deliveryMessages.Add(deliveryMessage);
}
}
else
{
var nominativo = string.Empty;
if (persona != null)
nominativo = persona.DisplayName;
var destinatario = string.Join(",", destinatari);
deliveryMessages.Add(new DeliveryMessage(fullPathFile, nominativo, destinatario, referenceId));
}
// Se non viene passato in input creo una nuova delivery
delivery = new Delivery(idAzienda, motivoMessaggio.ToString(), deliveryMessages, new System.Net.Mail.MailAddress(mittente));
if (personaMessaggioDTO != null && personaMessaggioDTO.IdDelivery != null)
delivery.Id = personaMessaggioDTO.IdDelivery.Value;
_mailService.Send(delivery);
}
catch (Exception ex)
{
invioRiuscito = false;
message = "Si sono verificati problemi nell'invio del messaggio :" + Environment.NewLine + ex.Message;
_log.ErrorFormat("Errore inaspettato durante l'invio della mail - {0} - oggetto:{1} - testo:{2} - destinatario:{3} - nominativo:{4} - emlFile:{5}", ex, Utility.GetMethodDescription(), oggetto, testo, destinatari.Aggregate("<NESSUNO>", (current, dest) => current + (dest + ", ")), persona != null ? persona.DisplayName : "<NULL>", fullPathFile);
}
}
if (invioRiuscito)
{
var destinatarioStr = string.Empty;
foreach (var dest in destinatari)
{
if (!string.IsNullOrEmpty(destinatarioStr))
destinatarioStr += ",";
destinatarioStr += dest;
}
message = persona == null ? $"La mail è stata correttamente accodata: {destinatarioStr}"
: $"La mail è stata correttamente accodata: {persona.DisplayName} - {destinatarioStr}";
// =====================================
// Controllo rapportino
// =====================================
//// 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);
//// Create a job specification for my job.
//var jobSpec = new JobSpec("Controllo rapportino", "Verifica e salvataggio email contenente rapportino di conferma di invio FAX", "ConfermaRicezioneMessaggio", 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.
//_scheduler.CreateJob(jobSpec, CreateJobConflictAction.Replace);
//// Start the scheduler.
//_scheduler.Start();
}
var risultatoInvio = new RisultatoInvioMessaggio(referenceId, referenceId, invioRiuscito, message, new DocumentInfo());
try
{
if (invioRiuscito)
{
if (motivoMessaggio != MotivoMessaggio.ScadenzaContratto && motivoMessaggio != MotivoMessaggio.NotificaResponsabileAttivita)
{
var allegatiMessaggio = new List<DocumentInfo>();
if (allegati != null)
allegatiMessaggio = allegati.ToList();
var storicoMessaggio = _messaggisticaService.StoricizzaMessaggio(persona, condominio, risultatoInvio, motivoMessaggio, oggetto, testo, destinatari, mittente, emailRapportino, allegatiMessaggio, TipoMessaggio.Email);
if (storicoMessaggio != null)
risultatoInvio.IdMessaggio = storicoMessaggio.ID;
}
risultatoInvio.IdDelivery = delivery.Id;
}
}
catch(Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la storicizzazione del messaggio - {0} - oggetto:{1} - destinatario:{2}", ex, Utility.GetMethodDescription(), oggetto, destinatari.Aggregate("<NESSUNO>", (current, dest) => current + (dest + ", ")));
throw;
}
return new List<RisultatoInvioMessaggio> { risultatoInvio};
}
public RisultatoInvioMessaggioAllegati InvioMessaggioPersone(MotivoMessaggio motivoMessaggio, string oggetto, string messaggio, IList<PersonaMessaggioDTO> persone, Dictionary<int, BindingList<ContattoDTO>> contatti, string mittente, string emailRapportino, IList<DocumentoMessaggioDTO> allegati, IList<DocumentInfo> allegatiNuovi, TipoMessaggio tipo, int? idModello, ParametriStampaUnione parametri, ParametriInvioLettera parametriInvioLettera, bool aggiornaContatti, int? idCondominio, UserInfo userinfo)
{
var retryCount = 5;
var success = false;
var windsorRep = new WindsorConfigRepository();
var item = new RisultatoInvioMessaggioAllegati();
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new MessaggioRepository(userinfo, windsorRep);
item = rep.InvioMessaggioPersone(motivoMessaggio, oggetto, messaggio, persone, contatti, mittente, emailRapportino, allegati, allegatiNuovi, tipo, idModello, parametri, parametriInvioLettera, aggiornaContatti, idCondominio, userinfo.Azienda);
if (parametriInvioLettera.Aggregazione == AggregazioneDocumentiEnum.DocumentoUnico)
{
item.Allegati = null;
item.RisultatoInvio = new List<RisultatoInvioMessaggio> {new RisultatoInvioMessaggio(null, null, true, "Il documento è stato correttamente generato", new DocumentInfo())};
}
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante l'invio del messaggio - TENTATIVO:{0} - {1} - oggetto:{2} - motivo:{3} - azienda:{4}", ex, (6 - retryCount), Utility.GetMethodDescription(), oggetto, motivoMessaggio, userinfo.Azienda);
windsorRep.Rollback();
if (!isRetryException(ex))
throw;
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (6 - retryCount));
retryCount--;
_log.InfoFormat("Invio del messaggio - INIZIO TENTATIVO:{0} - {1} - oggetto:{2} - motivo:{3} - azienda:{3}", ex, (6 - retryCount), Utility.GetMethodDescription(), oggetto, motivoMessaggio, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public IList<RisultatoInvioMessaggio> InvioMessaggio(CondominioDTO condominio, MotivoMessaggio motivoMessaggio, string oggetto, string messaggio, IList<PersonaContattoDTO> persone, Dictionary<int, List<ContattoDTO>> contatti, string mittente, string emailRapportino, IList<DocumentoDTO> allegati, IList<DocumentInfo> allegatiNuovi, TipoMessaggio tipo, ModelloLetteraDTO modello, ParametriStampaUnione parametri, ParametriInvioLettera parametriInvioLettera, bool aggiornaContatti)
{
// -----------------------------------------------
// Destinatari
// -----------------------------------------------
var personeMessaggio = persone.Select(persona => new PersonaMessaggioDTO {ID = persona.ID, TipoIndirizzo = persona.Indirizzo.RecapitoResidenza, IdUnitaImmobiliare = persona.IdUnitaImmobiliare}).ToList();
// -----------------------------------------------
// Documenti Allegati
// -----------------------------------------------
var idDocumenti = new List<DocumentoMessaggioDTO>();
if (allegati != null)
{
idDocumenti.AddRange(allegati.Select(documento => new DocumentoMessaggioDTO {Id = documento.ID, IdSpesa = documento.IdSpesa}));
}
int? idModelloLettera = null;
if (modello != null)
idModelloLettera = modello.Id;
int? idCondominio = null;
if (condominio != null)
idCondominio = condominio.ID;
var result = new RisultatoInvioMessaggioAllegati();
try
{
result = GetServiceClient().InvioMessaggioPersone(motivoMessaggio, oggetto, messaggio, personeMessaggio, contatti, mittente, emailRapportino, idDocumenti, new List<DocumentInfo>(allegatiNuovi), tipo, idModelloLettera, parametri, parametriInvioLettera, aggiornaContatti, idCondominio, GetUserInfo());
}
catch (OutOfMemoryException ex)
{
_log.WarnFormat("Errore nell'invio del messaggio a persone - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio { InvioRiuscito = false, MessaggioInvio = $"La memoria non è sufficiente per l'invio del messaggio.{Environment.NewLine}Per eseguire l'invio del messaggio da questa postazione occorre aumentare la ram disponibile" } };
}
catch (CommunicationException ex)
{
_log.WarnFormat("Errore nell'invio del messaggio a persone - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio { InvioRiuscito = false, MessaggioInvio = $"La memoria non è sufficiente per l'invio del messaggio.{Environment.NewLine}Per eseguire l'invio del messaggio da questa postazione occorre aumentare la ram disponibile" } };
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'invio del messaggio a persone - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
throw;
}
finally
{
CloseService();
}
if (result.MessaggioGenerato.Body != null)
_manageDocumentService.Open(result.MessaggioGenerato, oggetto, true, MergeFieldType.Default, _aziendaService.GetAperturaDocumentoMessaggistica());
return result.RisultatoInvio;
}
public IList<RisultatoInvioMessaggio> InvioMessaggioPersonalizzato(CondominioDTO condominio, MotivoMessaggio motivoMessaggio, IList<PersonaMessaggioDTO> persone, string mittente, string emailRapportino, IList<DocumentoDTO> allegati, IList<DocumentInfo> allegatiNuovi, TipoMessaggio tipo, ModelloLetteraDTO modello, ParametriStampaUnione parametri, ParametriInvioLettera parametriInvioLettera, bool aggiornaContatti)
{
try
{
// -----------------------------------------------
// Documenti Allegati
// -----------------------------------------------
var idDocumenti = new List<int>();
if (allegati != null)
idDocumenti.AddRange(allegati.Where(item => item != null).Select(documento => documento.ID));
int? idCondominio = null;
if (condominio != null)
idCondominio = condominio.ID;
int? idModelloLettera = null;
if (modello != null)
idModelloLettera = modello.Id;
var result = GetServiceClient().InvioMessaggioPersonalizzato(motivoMessaggio, new List<PersonaMessaggioDTO>(persone), mittente, emailRapportino, idDocumenti, new List<DocumentInfo>(allegatiNuovi), tipo, idModelloLettera, parametri, parametriInvioLettera, aggiornaContatti, idCondominio, GetUserInfo());
CloseService();
if (result.MessaggioGenerato.Body != null)
_manageDocumentService.Open(result.MessaggioGenerato, parametri.Oggetto, true, MergeFieldType.Default);
return result.RisultatoInvio;
}
catch (Exception ex)
{
var idCondominio = "<NULL>";
if (condominio != null)
idCondominio = condominio.ID.ToString();
var idModelloLettera = "<NULL>";
if (modello != null)
idModelloLettera = modello.Id.ToString();
_log.FatalFormat("Errore nell'invio del messaggio - {0} - mittente:{1} - condominio:{2} - modello:{3}", ex, Utility.GetMethodDescription(), mittente, idCondominio, idModelloLettera);
throw;
}
}
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)
{
if (destinatari.Count > 0)
{
if(allegati.Count == 0)
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio(null, null, false, "Non è presente nessun messaggio da inviare", new DocumentInfo()) };
_parametriInvioLettera = parametriInvioLettera;
var results = new List<RisultatoInvioMessaggio>();
var allegatiLista = new List<DocumentInfo>(allegati.Count + 1);
Persona persona = null;
if (personaMessaggioDTO != null)
persona = _daoFactory.GetPersonaDao().Find(personaMessaggioDTO.ID, false);
try
{
// =====================================
// Elaborazione documenti allegati
// =====================================
var nomiFiles = new string[allegati.Count];
var contenutoAllegati = new byte[allegati.Count][];
// -------------------------------------
// Allegati
// -------------------------------------
var index = 0;
foreach (var documento in allegati)
{
var body = documento.Body;
var fileExtension = documento.FileExtension;
var fileName = documento.FileName;
// Se richiesto converto l'allegato in PDF
if (parametriInvioLettera.FormatoDocumento == FormatoDocumentoEnum.Pdf)
{
try
{
var doc = new Document(new MemoryStream(documento.Body));
var pdfStream = new MemoryStream();
doc.Save(pdfStream, SaveFormat.Pdf);
body = pdfStream.ToArray();
fileExtension = ".pdf";
}
catch (UnsupportedFileFormatException ex)
{
_log.WarnFormat("Formato file non supportato - {0} - fileId:{1} - fileName:{2} - extension:{3}", ex, Utility.GetMethodDescription(), documento.FileId, documento.FileName, documento.FileExtension);
}
catch (Exception ex)
{
_log.ErrorFormat("Formato file non supportato - {0} - fileId:{1} - fileName:{2} - extension:{3}", ex, Utility.GetMethodDescription(), documento.FileId, documento.FileName, documento.FileExtension);
}
}
nomiFiles[index] = fileName + fileExtension;
contenutoAllegati[index] = body;
// Se NON creo un file singolo i singoli documenti li allego al messaggio
if(parametriInvioLettera.Aggregazione == AggregazioneDocumentiEnum.DocumentiSeparati)
allegatiLista.Add(new DocumentInfo(body, documento.FileId, fileName, fileExtension));
index++;
}
var nomeFile = string.Empty;
// =====================================
// Creazione dello zip
// =====================================
byte[] messaggio = null;
if (parametriInvioLettera.Aggregazione == AggregazioneDocumentiEnum.DocumentiSeparati)
{
// ------------------------------------------
// Singolo ZIP con tutti i documenti per persona
// ------------------------------------------
var stream = new MemoryStream();
using (var zipFile = new ZipFile())
{
for (var i = 0; i < index; i++)
{
var zipEntry = zipFile.AddEntry(nomiFiles[i], contenutoAllegati[i]);
}
zipFile.Save(stream);
}
stream.Position = 0;
// ------------------------------------------
// Aggiungo allo zip unico
// ------------------------------------------
if (_fileSingolo == null)
_fileSingolo = new ZipFile();
nomeFile = persona != null ? $"{(_fileSingolo.Count + 1).ToString().PadLeft(3, '0')} - {persona.ID.ToString().PadLeft(8, '0')} - {persona.DisplayName}.zip"
: oggetto;
_fileSingolo.AddEntry(nomeFile, stream);
messaggio = stream.ToArray();
}
else
{
if (index > 0)
{
// Se è presente più di un allegato eseguo veramente un merge, altrimenti, per evitare problemi
// di orientamento e dimensione del pdf finale, se ho un solo allegato prendo questo come documento finale
if (index > 1)
{
if (parametriInvioLettera.FormatoDocumento == FormatoDocumentoEnum.Pdf)
{
var pdfMerge = new PdfMerge { EnablePagination = parametriInvioLettera.RinumeraPagine };
IList<byte[]> documenti = new List<byte[]>(contenutoAllegati.Length);
for (var i = 0; i < index; i++)
{
if (nomiFiles[i].EndsWith(".pdf"))
documenti.Add(contenutoAllegati[i]);
}
messaggio = pdfMerge.Merge(documenti, true);
}
else
{
// The document that the other documents will be appended to.
var doc = new Document();
// We should call this method to clear this document of any existing content.
doc.RemoveAllChildren();
for (var i = 0; i < index; i++)
{
try
{
// Open the document to join.
var srcDoc = new Document(new MemoryStream(contenutoAllegati[i]));
// Append the source document at the end of the destination document.
doc.AppendDocument(srcDoc, ImportFormatMode.UseDestinationStyles);
// In automation you were required to insert a new section break at this point, however in Aspose.Words we
// don't need to do anything here as the appended document is imported as separate sectons already.
// If this is the second document or above being appended then unlink all headers footers in this section
// from the headers and footers of the previous section.
if (i > 1)
doc.Sections[i].HeadersFooters.LinkToPrevious(false);
}
catch (UnsupportedFileFormatException ex)
{
_log.WarnFormat("Documento con formato non riconosciuto - {0} - index:{1}", ex, Utility.GetMethodDescription(), index);
}
}
var saveFormat = SaveFormat.Doc;
if(parametriInvioLettera.FormatoDocumento == FormatoDocumentoEnum.Docx)
saveFormat = SaveFormat.Docx;
using (var stream = new MemoryStream())
{
doc.Save(stream, saveFormat);
messaggio = stream.ToArray();
}
}
}
else
messaggio = contenutoAllegati[0];
// ----------------------------------------------------------------
// Aggiungo allo zip unico se richiesto un file unico per persona
// ----------------------------------------------------------------
if (parametriInvioLettera.Aggregazione == AggregazioneDocumentiEnum.DocumentoUnicoPerPersona)
{
if (_fileSingolo == null)
_fileSingolo = new ZipFile();
nomeFile = persona != null ?
$"{(_fileSingolo.Count + 1).ToString().PadLeft(3, '0')} - {persona.ID.ToString().PadLeft(8, '0')} - {persona.DisplayName}.{parametriInvioLettera.FormatoDocumento.ToString().ToLower()}"
: oggetto;
if (string.IsNullOrEmpty(nomeFile) && nomiFiles.Length > 0 && !string.IsNullOrEmpty(nomiFiles[0]))
nomeFile = nomiFiles[0];
if (string.IsNullOrEmpty(nomeFile))
nomeFile = $"Documento.{parametriInvioLettera.FormatoDocumento.ToString().ToLower()}";
_fileSingolo.AddEntry(nomeFile, messaggio);
}
else
{
if (parametriInvioLettera.FormatoDocumento == FormatoDocumentoEnum.Pdf)
{
var pdfMerge = new PdfMerge
{
EnablePagination = parametriInvioLettera.RinumeraPagine
};
if (_documentoSingolo != null)
pdfMerge.AddDocument(_documentoSingolo);
pdfMerge.AddDocument(messaggio);
using (var stream = new MemoryStream())
{
pdfMerge.Merge(stream, true);
_documentoSingolo = stream.ToArray();
}
}
else
{
var doc = new Document();
doc.RemoveAllChildren();
if (_documentoSingolo != null)
{
var singleDoc = new Document(new MemoryStream(_documentoSingolo));
doc.AppendDocument(singleDoc, ImportFormatMode.UseDestinationStyles);
}
var newDoc = new Document(new MemoryStream(messaggio));
doc.AppendDocument(newDoc, ImportFormatMode.UseDestinationStyles);
doc.Sections[0].HeadersFooters.LinkToPrevious(false);
var saveFormat = SaveFormat.Doc;
if (parametriInvioLettera.FormatoDocumento == FormatoDocumentoEnum.Docx)
saveFormat = SaveFormat.Docx;
using (var stream = new MemoryStream())
{
doc.Save(stream, saveFormat);
_documentoSingolo = stream.ToArray();
}
}
}
}
}
if (messaggio != null)
{
var fileExtension = $".{parametriInvioLettera.FormatoDocumento.ToString().ToLower()}";
var documentMessage = _documentService.SaveDocument(messaggio, nomeFile, fileExtension, null, idAzienda);
if (documentMessage.Documento != null)
{
var checkSumMessaggio = documentMessage.Documento.Checksum;
var destinatarioMessaggio = "Tutti";
if (persona != null)
destinatarioMessaggio = persona.DisplayName;
var messaggioInvio = $"Messaggio preparato per l'invio: {destinatarioMessaggio}";
var document = new DocumentInfo();
var nomeDocumento = persona != null ? $"Lettera {motivoMessaggio} {DateTime.Today:d MMMM yyyy} - {persona.DisplayName}"
: $"Lettera {motivoMessaggio} {DateTime.Today:d MMMM yyyy}";
if (parametriInvioLettera.ApriFileGenerato)
{
document = new DocumentInfo(messaggio, checkSumMessaggio, nomeDocumento, fileExtension) { BodyText = oggetto };
allegatiLista.Add(document);
}
var resultInvio = new RisultatoInvioMessaggio(checkSumMessaggio, checkSumMessaggio, true, messaggioInvio, document);
var storicoMessaggio = _messaggisticaService.StoricizzaMessaggio(persona, condominio, resultInvio, motivoMessaggio, oggetto, testo, destinatari, mittente, emailRapportino, allegatiLista, TipoMessaggio.Manuale);
if (storicoMessaggio != null)
resultInvio.IdMessaggio = storicoMessaggio.ID;
results.Add(resultInvio);
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del messaggio - {0} - oggetto:{1} - destinatario:{2}", ex, Utility.GetMethodDescription(), oggetto, destinatari[0]);
throw;
}
return results;
}
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio(null, null, false, "Non è definito nessun destinatario", new DocumentInfo()) };
}
public RisultatoInvioMessaggioAllegati NotificaAIncaricato(int idAttivita, MotivoMessaggio motivoMessaggio, IList<PersonaMessaggioDTO> persone, string oggettoMessaggio, string testoMessaggio, string mittente, string emailRapportino, IList<DocumentoMessaggioDTO> allegati, IList<DocumentInfo> allegatiNuovi, TipoMessaggio tipo, int? idModello, ParametriStampaUnione parametri, ParametriInvioLettera parametriInvioLettera, bool aggiornaContatti, int? idCondominio, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var repo = new AttivitaRepository(userinfo, windsorRep);
var item = repo.NotificaAIncaricato(idAttivita, motivoMessaggio, persone, oggettoMessaggio, testoMessaggio, mittente, emailRapportino, allegati, allegatiNuovi, tipo, idModello, parametri, parametriInvioLettera, aggiornaContatti, idCondominio);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.Error("Errore nell'invio della lettera - " + Utility.GetMethodDescription() + " - idAttivita:" + idAttivita + " - persone:" + persone.Aggregate(string.Empty, (current, persona) => current + (persona.ID + ", ")), ex);
windsorRep.Rollback();
throw;
}
}
public RisultatoInvioMessaggioAllegati InvioMessaggioPersonalizzato(MotivoMessaggio motivoMessaggio, IList<PersonaMessaggioDTO> persone, string mittente, string emailRapportino, IList<int> allegati, IList<DocumentInfo> allegatiNuovi, TipoMessaggio tipo, int? idModello, ParametriStampaUnione parametri, ParametriInvioLettera parametriInvioLettera, bool aggiornaContatti, int? idCondominio, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new MessaggioRepository(userinfo, windsorRep);
var item = rep.InvioMessaggioPersonalizzatoPersone(motivoMessaggio, persone, mittente, emailRapportino, allegati, allegatiNuovi, tipo, idModello, parametri, parametriInvioLettera, aggiornaContatti, idCondominio, userinfo.Azienda);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.Error("Errore durante l'invio del messaggio - " + Utility.GetMethodDescription() + " - idAzienda:" + userinfo.Azienda, ex);
windsorRep.Rollback();
throw;
}
}
public DialogResult OpenDialogFormInvioMessaggio(TipoMessaggio? tipoMessaggio, List<int> destinatari, ModelloLetteraDTO modelloLettera, string contattoMittente, ParametriStampaUnione parametriLettera)
{
DialogResult result;
using (var form = new InvioMessaggioUI(tipoMessaggio, contattoMittente, parametriLettera))
{
if (destinatari != null && destinatari.Count > 0)
form.LoadPersone(destinatari);
if (modelloLettera != null)
form.LoadModello(modelloLettera);
if (!string.IsNullOrEmpty(_customText))
form.ShowInserisciTestoCustom(_customText);
if (!string.IsNullOrEmpty(_userInfoText))
form.ShowInserisciUserInfo(_userInfoText);
result = form.ShowDialog();
if (result != DialogResult.Cancel)
{
_contattiSelected = form.GetContattiSelected();
_contattoDaContattare = form.GetContattoDaContattare();
_personaDaContattare = form.GetPersonaDaContattare();
_modelloLettera = form.GetModelloLettera();
_emailRapportino = form.GetEmailRapportino();
_testoMessaggio = form.GetTestoMessaggio();
_oggettoMessaggio = form.GetOggettoMessaggio();
_invioVeloce = form.GetInvioVeloce();
_messageType = form.GetMessageType();
_colore = form.GetColore();
_apriFile = form.GetApriFile();
_aggregazione = form.GetAggregazioneDocumenti();
_formatoDocumento = form.GetFormatoDocumento();
_accodaMessaggio = form.GetAccodaMessaggio();
_numeraPagine = form.GetNumeraPagine();
_fronteRetro = form.GetFronteRetro();
_primaPaginaMittente = form.GetPrimaPaginaMittente();
_mittente = form.GetMittente();
_tipoMessaggio = form.GetTipoMessaggio();
_documenti = form.GetDocumenti();
_documentiNew = form.GetDocumentiNew();
_parametriInvioLettera = new ParametriInvioLettera { Tipo = form.GetMessageType() };
_aggiornaContatti = form.GetAggiornaContatti();
}
form.CloseForm();
}
Application.DoEvents();
return result;
}
public RisultatoInvioMessaggioAllegati InvioMessaggioPersonalizzatoPersone(MotivoMessaggio motivoMessaggio, IList<PersonaMessaggioDTO> persone, string mittente, string emailRapportino, IList<int> documentiAllegati, IList<DocumentInfo> allegatiNuovi, TipoMessaggio tipo, int? idModello, ParametriStampaUnione parametri, ParametriInvioLettera parametriInvioLettera, bool aggiornaContatti, int? idCondominio, int azienda)
{
try
{
var result = new List<RisultatoInvioMessaggio>();
var messaggioInviato = new DocumentInfo();
if (persone.Count > 0)
{
IMessageService service = null;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
Condominio condominio = null;
if (idCondominio > 0)
condominio = daoFactory.GetCondominioDao().Find(idCondominio.GetValueOrDefault(), false);
switch (tipo)
{
case TipoMessaggio.Fax:
service = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMessageService>("messageservice.fax");
break;
case TipoMessaggio.Email:
service = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMessageService>("messageservice.email");
break;
case TipoMessaggio.Sms:
service = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMessageService>("messageservice.sms");
break;
case TipoMessaggio.Lettera:
service = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMessageService>("messageservice.lettera");
break;
case TipoMessaggio.Manuale:
service = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMessageService>("messageservice.manuale");
break;
}
// Recupero l'eventuale modello di lettera (solo per Fax, Email o Lettera tradizionale)
ModelloLettera modello = null;
if (idModello != null)
modello = daoFactory.GetModelloLetteraDao().GetById(idModello.Value, false);
var personaService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IPersonaService>();
var modelloLetteraService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IModelloLetteraService>();
// =========================================================================================
// Allegati
// =========================================================================================
var allegatiMessaggio = new List<DocumentInfo>();
var documentoRepository = new DocumentoRepository(_info, _windsorRepository);
foreach (var idDocumento in documentiAllegati)
{
var documento = daoFactory.GetDocumentoDao().Find(idDocumento, false);
if (documento != null)
{
var tipoDocumento = TipoDocumentoArchiviazione.Contratto;
if (documento.SpesaRiferimento != null)
tipoDocumento = TipoDocumentoArchiviazione.FatturaPassiva;
var docInfo = documentoRepository.GetDocumentInfo(idDocumento, tipoDocumento);
// Se è un file word lo conveerto in PDF
if (tipo != TipoMessaggio.Manuale && (docInfo.FileExtension == ".doc" || docInfo.FileExtension == ".docx"))
{
var doc = new Document(new MemoryStream(docInfo.Body));
var pdfStream = new MemoryStream();
doc.Save(pdfStream, SaveFormat.Pdf);
docInfo.Body = pdfStream.ToArray();
docInfo.FileExtension = ".pdf";
}
allegatiMessaggio.Add(docInfo);
}
}
// =========================================================================================
// Allegati Nuovi
// =========================================================================================
var allegatiNuoviAry = allegatiNuovi.ToArray();
for (var i = 0; i < allegatiNuoviAry.Length; i++)
{
var documentMessage = getDocumentService().SaveDocument(allegatiNuovi[i].Body, allegatiNuoviAry[i].FileName, allegatiNuoviAry[i].FileExtension, null, _info.Azienda);
if (documentMessage.Documento != null)
{
var checksum = documentMessage.Documento.Checksum;
allegatiNuoviAry[i].FileId = checksum;
byte[] body = null;
var fileExtension = string.Empty;
var fileName = string.Empty;
if (tipo != TipoMessaggio.Manuale && (allegatiNuoviAry[i].FileExtension == ".doc" || allegatiNuoviAry[i].FileExtension == ".docx" || allegatiNuoviAry[i].FileExtension == ".rtf"))
{
try
{
var doc = new Document(new MemoryStream(allegatiNuovi[i].Body));
var pdfStream = new MemoryStream();
doc.Save(pdfStream, SaveFormat.Pdf);
body = pdfStream.ToArray();
fileExtension = ".pdf";
fileName = allegatiNuoviAry[i].FileName;
}
catch (Exception ex)
{
_log.WarnFormat("Errore nella conversione del file in pdf - {0} - fileName:{1} - fileExtension:{2} - fileId:{3}", ex, Utility.GetMethodDescription(), allegatiNuoviAry[i].FileName, allegatiNuoviAry[i].FileExtension, allegatiNuoviAry[i].FileId);
}
}
// Se la conversione non è stata eseguita o è fallita prendo il file originale
if (body == null)
{
body = allegatiNuovi[i].Body;
fileExtension = allegatiNuovi[i].FileExtension;
fileName = allegatiNuovi[i].FileName;
}
var index = fileName.LastIndexOf(".");
if (index > -1)
fileName = fileName.Substring(0, index);
var documento = new DocumentInfo { Body = body, FileId = checksum, FileName = fileName, FileExtension = fileExtension };
allegatiMessaggio.Insert(0, documento);
}
}
// =========================================================================================
// Per ogni persona invio il messaggio
// =========================================================================================
foreach (var personaMessaggio in persone)
{
var allegatiInvio = allegatiMessaggio.ToList();
var persona = daoFactory.GetPersonaDao().Find(personaMessaggio.ID, false);
if (persona != null)
{
parametri.IdPersonaAttiva = persona.ID;
parametri.Importo = personaMessaggio.Importo;
if(idCondominio != null)
parametri.IdCondominio = idCondominio.Value;
var contattiCollection = new ContattoCollection(persona.Contatti);
var contattoFax = contattiCollection.GetFirstContatto<Fax>();
if (contattoFax != null)
parametri.FaxDestinatario = contattoFax.Valore;
var messaggioPrincipale = personaMessaggio.TestoMessaggio;
parametri.Body = messaggioPrincipale;
switch (tipo)
{
case TipoMessaggio.Fax:
case TipoMessaggio.Lettera:
case TipoMessaggio.Email:
case TipoMessaggio.Manuale:
// ----------------------------------------------------------------
// Modello RTF stampa unione
// ----------------------------------------------------------------
if(modello != null)
{
var documentoStampaUnione = modelloLetteraService.GetLetteraCompilata(idModello.GetValueOrDefault(), parametri);
// Salvo il documento nel file system
var documentMessage = getDocumentService().SaveDocument(documentoStampaUnione.Body, documentoStampaUnione.FileName + documentoStampaUnione.FileExtension, documentoStampaUnione.FileExtension, null, _info.Azienda);
if (documentMessage.Documento != null)
{
var checksumModello = documentMessage.Documento.Checksum;
documentoStampaUnione.FileId = checksumModello;
allegatiInvio.Insert(0, documentoStampaUnione);
}
}
// ----------------------------------------------------------------
// Documento principale (es. lettera di sollecito, subentro ecc...)
// ----------------------------------------------------------------
if (personaMessaggio.DocumentoMessaggio != null)
{
// Salvo il documento nel file system
var documentMessage = getDocumentService().SaveDocument(personaMessaggio.DocumentoMessaggio, personaMessaggio.NomeMessaggio + ".pdf", ".pdf", null, _info.Azienda);
if (documentMessage.Documento != null)
{
var checksumFax = documentMessage.Documento.Checksum;
allegatiInvio.Insert(0, new DocumentInfo(personaMessaggio.DocumentoMessaggio, checksumFax, personaMessaggio.NomeMessaggio, ".pdf") { Length = personaMessaggio.DocumentoMessaggio.Length });
}
}
break;
}
var destinatari = personaService.GetContattiSelezionatiByTipo(persone.Where(item => item.ID == persona.ID).ToList(), tipo);
if (service != null)
result.AddRange(service.InvioMessaggio(azienda, personaMessaggio, condominio, parametri.IdUnitaImmobiliare, parametri.IdFornitore, parametri.IdResponsabile, parametri.IdIncaricatoAttivita, motivoMessaggio, personaMessaggio.OggettoMessaggio, messaggioPrincipale, destinatari, mittente, emailRapportino, allegatiInvio, parametriInvioLettera));
}
}
if (parametriInvioLettera.AccodaMessaggio || parametriInvioLettera.ApriFileGenerato)
{
var zipFile = service.FinalizzaMessaggio(parametri.Oggetto, parametriInvioLettera.AccodaMessaggio, azienda);
if (parametriInvioLettera.ApriFileGenerato)
messaggioInviato = zipFile;
}
}
else
result.Add(new RisultatoInvioMessaggio(string.Empty, null, false, "Non è presente nessun destinatario", new DocumentInfo()));
// ========================================
// Aggiorno i contatti
// ========================================
if (aggiornaContatti)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
foreach (var personaMessaggio in persone)
{
var persona = daoFactory.GetPersonaDao().Find(personaMessaggio.ID, false);
if (persona != null)
{
var contattoRepository = new ContattoRepository(persona, _info, _windsorRepository);
foreach (var contattoDTO in personaMessaggio.Contatti)
{
contattoDTO.Stato = "U";
contattoRepository.ManageDomainEntity(contattoDTO, true);
}
}
}
}
return new RisultatoInvioMessaggioAllegati(result, null, messaggioInviato);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante l'invio del messaggio - {0} - idAzienda:{1}", ex, Utility.GetMethodDescription(), azienda);
throw;
}
}
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)
{
try
{
if (destinatari.Count > 0)
{
var message = string.Empty;
var invioRiuscito = false;
var allegatiLista = new List<DocumentInfo>(allegati.Count);
Persona persona = null;
if (personaMessaggioDTO != null)
persona = _daoFactory.GetPersonaDao().Find(personaMessaggioDTO.ID, false);
var results = new List<RisultatoInvioMessaggio>();
var result = new eMessageResultSendFAX();
try
{
int? idCondominio = null;
if (condominio != null)
idCondominio = condominio.ID;
var destinatariSend = new List<string>();
foreach (var item in destinatari)
{
if (!item.Trim().StartsWith("+39"))
destinatariSend.Add("+39" + Conversione.ToPhoneNumber(item));
else
destinatariSend.Add(Conversione.ToPhoneNumber(item));
}
// =====================================
// Creo le pagine del FAX
// =====================================
var nomiFiles = new string[allegati.Count];
var contenutoAllegati = new byte[allegati.Count][];
// -------------------------------------
// Allegati
// -------------------------------------
var index = 0;
foreach (var documento in allegati)
{
nomiFiles[index] = documento.FileName + documento.FileExtension;
contenutoAllegati[index] = documento.Body;
allegatiLista.Add(documento);
index++;
}
// -------------------------------------
// Oggetto
// -------------------------------------
decimal? importo = null;
var tipoIndirizzo = TipoIndirizzo.Recapito;
if (personaMessaggioDTO != null)
{
importo = personaMessaggioDTO.Importo;
tipoIndirizzo = personaMessaggioDTO.TipoIndirizzo;
}
var parametri = new ParametriStampaUnione(persona != null ? (int?)persona.ID : null, idUnitaImmobiliare, idResponsabile, idIncaricatoAttivita, idFornitore, idCondominio, null, tipoIndirizzo, importo, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null);
oggetto = _messaggisticaService.ApplicaStampaUnione(oggetto, parametri, idAzienda);
// =====================================
// Invio Messaggio
// =====================================
// -------------------------------------
// Invio
// -------------------------------------
var service = new Fax { Timeout = 999999999 };
var userService = new Users();
var credenziali = _configurationService.GetLoginInfo(idAzienda);
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}", ex, Utility.GetMethodDescription(), credenziali.Value.Utente, credenziali.Value.Password);
}
if (success)
{
var identificazioneMittente = _configurationService.GetIdentificazioneMittente(idAzienda, TipoMessaggio.Fax, TipoIndirizzo.Recapito);
// Controllo identificazione mittente
if (string.IsNullOrEmpty(identificazioneMittente.Numero))
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio("KO", null, false, "Il fax non può essere inviato perchè non è presente il numero di fax del mittente" + Environment.NewLine + "Inserire il numero nella anagrafica dello studio e riprovare.", new DocumentInfo()) };
if (!string.IsNullOrEmpty(identificazioneMittente.Email))
{
if (!string.IsNullOrEmpty(emailRapportino))
emailRapportino += ",";
emailRapportino += identificazioneMittente.Email;
}
// Mittente
if (string.IsNullOrEmpty(mittente))
mittente = identificazioneMittente.Nome;
if (ConfigurationManager.AppSettings["IsTest"] != null && bool.Parse(ConfigurationManager.AppSettings["IsTest"]))
destinatariSend = new List<string> { "+390513371992" };
var parameters = new List<OptionalParameters>
{
new OptionalParameters { ParameterName = "NotificationEmail", ParameterValue = emailRapportino },
new OptionalParameters { ParameterName = "DeliveryTime", ParameterValue = DateTime.Now.ToString() },
new OptionalParameters { ParameterName = "HeaderFax", ParameterValue = identificazioneMittente.Numero },
new OptionalParameters { ParameterName = "HeaderName", ParameterValue = mittente }
};
if (!parametriInvioLettera.Asincrono)
result = service.Send(credenziali.Value.Utente, credenziali.Value.Password, destinatariSend.ToArray(), contenutoAllegati, nomiFiles, parameters.ToArray());
else
{
service.SendAsync(credenziali.Value.Utente, credenziali.Value.Password, destinatariSend.ToArray(), contenutoAllegati, nomiFiles, parameters.ToArray());
invioRiuscito = true;
}
message += result;
_log.InfoFormat("Risultato invio fax:{0} - destinatario:{1}", result, destinatariSend.Aggregate(string.Empty, (current, dest) => current + (dest + ", ")));
if (result.SpeditionResult.All(item => item.success))
invioRiuscito = true;
}
else
{
_log.WarnFormat("Credenziali non valide - {0} - username:{1} - password:{2}", Utility.GetMethodDescription(), credenziali.Value.Utente, credenziali.Value.Password);
}
}
else
{
_log.FatalFormat("Errore inaspettato durante l'invio del fax. NON sono presenti le credenziali per l'invio del fax - {0} - oggetto:{1} - destinatario:{2}", Utility.GetMethodDescription(), oggetto, destinatari[0]);
message = "KO - Non sono definite le credenziali per l'invio dei fax";
}
}
catch (Exception ex)
{
invioRiuscito = false;
_log.FatalFormat("Errore inaspettato durante l'invio del fax - {0} - oggetto:{1} - destinatario:{2}", ex, Utility.GetMethodDescription(), oggetto, destinatari[0]);
message = "KO - Errore inaspettato durante l'invio del fax";
}
if (motivoMessaggio != MotivoMessaggio.ScadenzaContratto && invioRiuscito)
{
foreach (var singleResult in result.SpeditionResult)
{
try
{
string messaggioInvio;
if (singleResult.success)
{
messaggioInvio = string.Format("Fax accodato per l'invio: {0}", singleResult.jobCode);
_log.InfoFormat("Invio FAX RIUSCITO - {0} - messageCode: {1} - messaggio: {2} - jobcode: {3} - destinatario: {4}", Utility.GetMethodDescription(), singleResult.messageCode, singleResult.errorDescription, singleResult.jobCode, destinatari.Aggregate(string.Empty, (current, dest) => current + (dest + ";")));
}
else
{
messaggioInvio = "Invio della lettera non riuscito:" + Environment.NewLine + singleResult.errorDescription;
_log.WarnFormat("Invio FAX FALLITO - {0} - messageCode: {1} - messaggio: {2} - jobcode: {3} - destinatario: {4}", Utility.GetMethodDescription(), singleResult.messageCode, singleResult.errorDescription, singleResult.jobCode, destinatari.Aggregate(string.Empty, (current, dest) => current + (dest + ";")));
}
var resultInvio = new RisultatoInvioMessaggio(singleResult.jobCode, singleResult.messageCode, singleResult.success, messaggioInvio, new DocumentInfo());
var storicoMessaggio = _messaggisticaService.StoricizzaMessaggio(persona, condominio, resultInvio, motivoMessaggio, oggetto, testo, destinatari, mittente, emailRapportino, allegatiLista, TipoMessaggio.Fax);
if (storicoMessaggio != null)
resultInvio.IdMessaggio = storicoMessaggio.ID;
results.Add(resultInvio);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la storicizzazione del messaggio - {0} - oggetto:{1} - destinatario:{2}", ex, Utility.GetMethodDescription(), oggetto, destinatari[0]);
throw;
}
}
}
else
{
if (!invioRiuscito)
results.Add(new RisultatoInvioMessaggio("KO", null, false, message, new DocumentInfo()));
}
return results;
}
}
catch (Exception ex)
{
var idPersona = "<NULL>";
if (personaMessaggioDTO != null)
idPersona = personaMessaggioDTO.ID.ToString();
var idCondominio = "<NULL>";
if (condominio != null)
idCondominio = condominio.ID.ToString();
_log.FatalFormat("Errore inaspettato nell'invio del fax - {0} - azienda:{1} - persona:{2} - condominio:{3} - motivoMessaggio:{4} - oggetto:{5} - testo:{6} - destinatari:{7} - mittente:{8} - emailRapportino:{9}", ex, Utility.GetMethodDescription(), idAzienda, idPersona, idCondominio, motivoMessaggio, oggetto, testo, destinatari.Aggregate(string.Empty, (current, dest) => current + (dest + ", ")), mittente, emailRapportino);
throw;
}
return new List<RisultatoInvioMessaggio> { new RisultatoInvioMessaggio(null, null, false, "Non è definito nessun destinatario", new DocumentInfo())};
}
public RisultatoInvioMessaggioAllegati NotificaAIncaricato(int idAttivita, MotivoMessaggio motivoMessaggio, IList<PersonaMessaggioDTO> persone, string oggettoMessaggio, string testoMessaggio, string mittente, string emailRapportino, IList<DocumentoMessaggioDTO> allegati, IList<DocumentInfo> allegatiNuovi, TipoMessaggio tipo, int? idModello, ParametriStampaUnione parametri, ParametriInvioLettera parametriInvioLettera, bool aggiornaContatti, int? idCondominio)
{
try
{
// Invio i messaggi
var messaggioRepository = new MessaggioRepository(_info, _windsorRepository);
var contatti = persone.ToDictionary(personaMessaggioDTO => personaMessaggioDTO.ID, personaMessaggioDTO => new BindingList<ContattoDTO>(personaMessaggioDTO.Contatti));
var risultatoInvio = messaggioRepository.InvioMessaggioPersone(motivoMessaggio, oggettoMessaggio, testoMessaggio, persone, contatti, mittente, emailRapportino, allegati, allegatiNuovi, tipo, idModello, parametri, parametriInvioLettera, aggiornaContatti, idCondominio, _info.Azienda);
// Associo i messaggi avviati con l'attività
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var attivita = daoFactory.GetAttivitaDao().Find(idAttivita, false);
if (attivita != null)
{
foreach (var risultatoInvioMessaggio in risultatoInvio.RisultatoInvio)
{
if (risultatoInvioMessaggio.InvioRiuscito && risultatoInvioMessaggio.IdMessaggio > 0)
{
var attivitaMessaggio = new AttivitaMessaggio(attivita, daoFactory.GetStoricoMessaggioDao().GetById(risultatoInvioMessaggio.IdMessaggio, false));
daoFactory.GetAttivitaMessaggioDao().SaveOrUpdate(attivitaMessaggio);
}
}
// Salvo tutti i documenti legandoli alla attività
foreach (var documentInfo in risultatoInvio.Allegati)
{
var documento = new Documento(documentInfo.FileId, documentInfo.FileName, documentInfo.FileExtension, "Attivita", false, daoFactory.GetAziendaDao().GetById(attivita.PraticaRiferimento.AziendaID.GetValueOrDefault(), false))
{
Descrizione = documentInfo.BodyText,
AttivitaRiferimento = attivita
};
daoFactory.GetDocumentoDao().SaveOrUpdate(documento);
}
// Documenti generati dall'invio manuale del messaggio
foreach (var itemResult in risultatoInvio.RisultatoInvio)
{
if (itemResult.Messaggio.Body != null)
{
var documentoLettera = new Documento(itemResult.Messaggio.FileId, itemResult.Messaggio.FileName, itemResult.Messaggio.FileExtension, "Attivita", false, daoFactory.GetAziendaDao().GetById(attivita.PraticaRiferimento.AziendaID.GetValueOrDefault(), false))
{
Descrizione = itemResult.Messaggio.BodyText,
AttivitaRiferimento = attivita
};
daoFactory.GetDocumentoDao().SaveOrUpdate(documentoLettera);
}
}
}
return risultatoInvio;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante l'invio del messaggio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), _info.Azienda);
throw;
}
}