public ListaAlertAttivitaUI(AttivitaDTO attivita)
{
InitializeComponent();
_control = new ListaAlertAttivitaUC(attivita) { Dock = DockStyle.Fill };
panelAlert.Controls.Add(_control);
persistWindowComponent1.UserName = Security.Login.Instance.CurrentLogin().LoginName;
}
public AttivitaDTO[] GetAllAttivitaByAzienda(int idAzienda)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var lista = daoFactory.GetAttivitaDao().GetByAzienda(idAzienda);
var listAttivita = new AttivitaDTO[lista.Count];
var index = 0;
foreach (var attivita in lista)
{
listAttivita[index] = setDto(attivita);
index++;
}
return listAttivita;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento delle attivita - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), idAzienda);
throw;
}
}
public List<AttivitaDTO> GetAttivitaByExample(AttivitaDTO item, int idCondominioRiferimento)
{
var listaAttivita = GetAllAttivita();
var listAttivita = from attivita in listaAttivita
where (item.StatoAttivita == null || attivita.StatoAttivita == item.StatoAttivita) &&
(string.IsNullOrEmpty(item.TipoAttivitaRiferimento) || attivita.TipoAttivitaRiferimento.StartsWith(item.TipoAttivitaRiferimento)) &&
(item.IdIncaricato == 0 || attivita.IdIncaricato == item.IdIncaricato) &&
(item.IdResponsabileRiferimento == 0 || attivita.IdResponsabileRiferimento == item.IdResponsabileRiferimento) &&
(idCondominioRiferimento == 0 || idCondominioRiferimento == GetById(attivita.IdPraticaRiferimento).IdCondominioRiferimento)
select attivita;
return new List<AttivitaDTO>(listAttivita.ToList());
}
public ListaAlertAttivitaUC(AttivitaDTO attivita)
{
InitializeComponent();
_attivita = attivita;
inizializza();
}
public string SaveAttivita(PraticaDTO pratica, AttivitaDTO attivita, out AttivitaDTO attivitaSave)
{
attivitaSave = attivita;
attivita.AziendaID = Login.Instance.CurrentLogin().Azienda;
int? idAttivita;
var message = GetServiceClient().SetAttivita(out idAttivita, attivita, GetUserInfo());
if (idAttivita != null)
{
if (idAttivita == 0)
{
attivitaSave = new AttivitaDTO {ID = 0};
}
else
{
attivitaSave = GetByIdAttivita(idAttivita.Value);
pratica.Version = GetServiceClient().GetPraticaVersion(pratica.ID, GetUserInfo());
}
}
CloseService();
return message;
}
public void DeleteAttivita(AttivitaDTO attivita)
{
if (SferaServiceProxy.Instance.CurrentService().DeleteAttivita(attivita.ID));
}
public string InserimentoAttivita(AttivitaDTO attivitaAttuale, out AttivitaDTO attOut)
{
attOut = null;
string message = SferaServiceProxy.Instance.CurrentService().InserimentoAttivita(out attOut, attivitaAttuale);
return message;
}
public List<DocumentoDTO> GetDocumentiByAttivita(AttivitaDTO attivita)
{
return _documentoService.GetByAttivita(attivita);
}
protected override UpdatableStandardForm getDetailForm(AttivitaDTO dataSourceItem, string bandName)
{
var pratica = getPraticaService().GetById(dataSourceItem.IdPraticaRiferimento);
var form = new DettaglioAttivitaUI (dataSourceItem, pratica);
form.AfterUpdate += formAfterUpdate;
form.NewEnabled = false;
_forms.Add(form);
return form;
}
public DocumentiUC(AttivitaDTO attivita)
{
InitializeComponent();
_attivita = attivita;
}
private void btnNewDocument_Click(object sender, EventArgs e)
{
NuovoDocumento nuovoDoc = new NuovoDocumento();
DialogResult result = nuovoDoc.ShowDialog(this);
if (result == DialogResult.OK)
{
FileInfo file = new FileInfo(nuovoDoc.DocumentFullPath);
long numBytes = file.Length;
FileStream fStream = new FileStream(nuovoDoc.DocumentFullPath, FileMode.Open, FileAccess.Read);
BinaryReader br = new BinaryReader(fStream);
byte[] data = br.ReadBytes((int)numBytes);
br.Close();
fStream.Close();
string fileName = nuovoDoc.DocumentFullPath.Substring(nuovoDoc.DocumentFullPath.LastIndexOf("\\") + 1);
ImportazioneDocumento documento;
// Caricamento finestrella feedback per il salvataggio
if (_pratica != null)
documento = new ImportazioneDocumento(data, fileName, nuovoDoc.DescrizioneDocumento, _pratica);
else
documento = new ImportazioneDocumento(data, fileName, nuovoDoc.DescrizioneDocumento, _attivita);
documento.ShowDialog();
if (_pratica != null)
{
_pratica = documento.Pratica;
lista.DataSource = _pratica.Documenti;
}
else
{
_attivita = documento.Attivita;
lista.DataSource = _attivita.Documenti;
}
}
}
public DettaglioAttivitaUI(AttivitaDTO attivita, PraticaDTO pratica)
{
InitializeComponent();
try
{
_pratica = pratica;
inizializza(attivita.StatoAttivita);
Attivita = attivita;
// Referente
var responsabile = getReferenteService().GetByCacheId(attivita.IdResponsabileRiferimento);
if (responsabile != null)
{
referenteDTOBindingSource.DataSource = getReferenteService().GetAllEffettivi();
if (responsabile.Sostitutivo != 0)
{
responsabile = getReferenteService().GetByCacheId(responsabile.Sostitutivo);
cmbResponsabile.Value = responsabile.ID;
}
else
cmbResponsabile.Value = responsabile.ID;
}
// Pratica
if (_pratica != null)
{
var descrizionePratica = string.Empty;
if (!string.IsNullOrEmpty(_pratica.Oggetto))
descrizionePratica = _pratica.Oggetto + " - ";
descrizionePratica += string.Format("Stato: {0}", _pratica.StatoPratica);
ulPratica.Text = descrizionePratica;
}
// Condominio
_condominio = getCondominioService().GetById(pratica.IdCondominioRiferimento, true);
if (_condominio != null)
ulCondominio.Text = _condominio.Codice + @" - " + _condominio.Descrizione;
//Data Scadenza
oraFinePrevista.Text = attivita.DataFinePrevista.GetValueOrDefault().TimeOfDay.ToString();
cmbDataFinePrevista.Text = attivita.DataFinePrevista.GetValueOrDefault().Date.ToString();
// Allegati
backgroundWorkerLoadDocumenti.RunWorkerAsync(attivita);
// Incaricati
var incaricati = getPraticaService().GetIncaricatiByCondominio(_condominio);
richiedenteDTOBindingSource.DataSource = incaricati;
cmbIncaricato.Value = Attivita.IdIncaricato;
if (cmbIncaricato.Value == null)
{
if (Attivita.IdIncaricato > 0)
{
var incaricatoReferente = getReferenteService().GetByCacheId(Attivita.IdIncaricato);
if (_condominio != null)
incaricati.Insert(0, new RichiedentePraticaDTO
{
IdPersona = incaricatoReferente.PersonaId,
DisplayNominativo = Attivita.NominativoIncaricato,
Id = Attivita.IdIncaricato,
IdCondominio = _condominio.ID,
Tipo = "Attivo"
});
}
richiedenteDTOBindingSource.DataSource = incaricati;
cmbIncaricato.Value = Attivita.IdIncaricato;
}
modelloLetteraDTOBindingSource.DataSource = getModelloLetteraService().GetModelliLettera(new List<TipoModelloLetteraEnum> { TipoModelloLetteraEnum.Messaggistica });
modelliLettera.SelectedIndex = 0;
tipiAttivitaBindingSource.DataSource = getPraticaService().GetAllTipoAttivita();
attivitaSource.DataSource = Attivita;
BusinessClass = new BaseDTOOfint[] { Attivita };
int? idCondominio = null;
if (_condominio != null)
idCondominio = _condominio.ID;
// Note
if (Utility.IsRTF(Attivita.Note))
txtNote.LoadDocumento(idCondominio, Conversione.ToStream(Attivita.Note), "RTF");
else if (Utility.IsHtml(Attivita.Note))
txtNote.LoadDocumento(idCondominio, Conversione.ToStream(Attivita.Note), "HTML");
else
txtNote.LoadDocumento(idCondominio, Conversione.ToStream(Attivita.Note), "PLAIN");
cmbIncaricato.ValueChanged += cmbIncaricatoValueChanged;
}
catch (Exception ex)
{
var idAttivita = string.Empty;
if (attivita != null)
idAttivita = attivita.ID.ToString();
var idPratica = string.Empty;
if (pratica != null)
idPratica = pratica.ID.ToString();
_log.Error("Errore durante la inizializzazione della attività - " + Utility.GetMethodDescription() + " - idPratica:" + idPratica + " - idAttività:" + idAttivita + " - azienda:" + Security.Login.Instance.CurrentLogin().Azienda, ex);
throw;
}
}
private AttivitaDTO conferma(bool messaggioConferma)
{
try
{
var attivitaInserita = new AttivitaDTO();
validationSummary1.Validate();
if (validationSummary1.IsValid)
{
if (_pratica != null)
{
DialogResult = DialogResult.OK;
var attivita = new AttivitaDTO
{
AziendaID = Login.Instance.CurrentLogin().Azienda,
AddebitoCompetenze = AddebitoCompetenze,
Contrattuale = Contrattuale,
DataFinePrevista = DataFinePrevista,
Note = Note,
Fatturata = Fatturata,
IdPraticaRiferimento = _pratica.ID,
IdResponsabileRiferimento = Responsabile,
IdFornitore = IdFornitore,
ImportoCompetenze = ImportoCompetenze,
TipoAttivitaRiferimento = TipoAttivita,
AlertScadenzaAbilitato = alertAbilitato.Checked,
IdNuoviMessaggi = new List<int>(),
Urgenza = (int)Urgenza
};
var incaricato = getIncaricato();
if (incaricato != null)
attivita.IdIncaricato = incaricato.Id;
var message = getPraticaService().InserimentoAttivita(_pratica, attivita, out attivitaInserita);
if (attivitaInserita != null && string.IsNullOrEmpty(message))
{
foreach (var documentoDTO in _documenti)
{
getPraticaService().SetDocumentoAttivita(attivitaInserita, documentoDTO);
}
NuovaAttivita = attivitaInserita;
if (messaggioConferma)
CommonMessages.DisplayComplete("L'inserimento della attività è terminato correttamente.");
}
else
{
CommonMessages.DisplayWarning("Si è verificato un errore. " + message);
DialogResult = DialogResult.Abort;
}
}
}
else
{
validationSummary1.ShowErrorSummary();
DialogResult = DialogResult.Abort;
}
return attivitaInserita;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante l'aggiornamento dell'attività - {0} - pratica:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), _pratica?.ID.ToString() ?? "<NULL>", Login.Instance.CurrentLogin().Azienda);
throw;
}
}
private void btnInviaClick(object sender, EventArgs e)
{
try
{
validationSummaryInvioMessaggio.Validate();
if (validationSummaryInvioMessaggio.IsValid)
{
PersonaDTO personaFornitore = null;
if (sceltaFornitoreCombo1.SelectedListaFornitore != null)
personaFornitore = getPersonaService().GetById(sceltaFornitoreCombo1.SelectedListaFornitore.IdPersona);
var numeroFaxFornitore = string.Empty;
if (personaFornitore != null && getPersonaService().GetContattiByTipo(personaFornitore, "Fax").Count > 0)
{
var contattiFornitore = getPersonaService().GetContattiByTipo(personaFornitore, "Fax");
if(contattiFornitore.Count > 0)
numeroFaxFornitore = contattiFornitore[0].Valore;
}
var parametri = new ParametriStampaUnione
{
IdCondominio = _condominio.ID,
IdPersonaRichiedente = _pratica.IdPersonaRiferimento,
DataAttiva = cmbDataFinePrevista.DateTime,
ContattiDestinatario = numeroFaxFornitore,
Identificativo = Attivita.ID.ToString(CultureInfo.InvariantCulture)
};
if (personaFornitore != null)
parametri.IdPersonaAttiva = personaFornitore.ID;
else if (cmbIncaricato.Value != null)
parametri.IdPersonaAttiva = ((RichiedentePraticaDTO) cmbIncaricato.ActiveRow.ListObject).IdPersona;
if (cmbResponsabile.Value != null)
parametri.IdResponsabile = ((ReferenteDTO)cmbResponsabile.ActiveRow.ListObject).PersonaId;
if (cmbIncaricato.Value != null)
parametri.IdIncaricatoAttivita = ((RichiedentePraticaDTO)cmbIncaricato.ActiveRow.ListObject).IdPersona;
if (sceltaFornitoreCombo1.SelectedListaFornitore != null)
parametri.IdFornitore = sceltaFornitoreCombo1.SelectedListaFornitore.ID;
var emailMittente = string.Empty;
if (cmbResponsabile.Value != null)
{
var responsabile = getReferenteService().GetByCacheId((int)cmbResponsabile.Value);
emailMittente = responsabile.Email;
}
var defaultTipoMessaggio = (TipoMessaggio)Enum.Parse(typeof(TipoMessaggio), tipoMessaggio.Text);
getInvioMessaggioUIService().ShowInserisciTestoCustom(getTestoMessaggio());
if (getInvioMessaggioUIService().OpenDialogFormInvioMessaggio(defaultTipoMessaggio, personaFornitore, null, emailMittente, parametri) == DialogResult.Yes)
{
parametri.Body = getInvioMessaggioUIService().GetTestoMessaggio();
parametri.Oggetto = getInvioMessaggioUIService().GetOggetto();
parametri.TelefonoDaContattare = getInvioMessaggioUIService().GetContattoDaContattare();
var personaDaContattare = getInvioMessaggioUIService().GetPersonaDaContattare();
if (personaDaContattare != null)
parametri.IdPersonaRichiedente = personaDaContattare.ID;
int? idModello = null;
var modello = getInvioMessaggioUIService().GetModelloLettera();
if (modello != null)
idModello = modello.Id;
// -----------------------------------------------------------------------------------------------------------------------------------------------
// Se il messaggio è email e è stato scelto un modello il testo della mail NON può essere ciò che l'utente ha scritto nella textarea devexpress
// quindi occorre definire, in questo caso un testo di default per la mail: GetTestoEmailAllegato()
// -----------------------------------------------------------------------------------------------------------------------------------------------
var tipoMessaggioSelezionato = getInvioMessaggioUIService().GetTipoMessaggio();
var testo = getInvioMessaggioUIService().GetTestoMessaggio();
if (tipoMessaggioSelezionato == TipoMessaggio.Email && idModello != null)
testo = getPraticaService().GetTestoEmailAllegato();
// -----------------------------------------------------------------------------------------------------------------------------------------------
var form = new ExecuteLoadDataObjectAsync<IList<RisultatoInvioMessaggio>>("Il messaggio è in corso di invio ....." + Environment.NewLine + "Si prega di attendere.");
Func<IList<RisultatoInvioMessaggio>> loadDati = () => getPraticaService().NotificaAIncaricato(_condominio.ID, Attivita, getInvioMessaggioUIService().GetContattiSelected(), getInvioMessaggioUIService().GetEmailRapportino(), getInvioMessaggioUIService().GetMittente(), getInvioMessaggioUIService().GetOggetto(), testo, getInvioMessaggioUIService().GetDocumenti(), getInvioMessaggioUIService().GetDocumentiNew(), idModello, parametri, getInvioMessaggioUIService().GetParametriInvioLettera(), tipoMessaggioSelezionato, getInvioMessaggioUIService().GetAggiornaContatti());
form.LoadData(loadDati);
form.ShowDialog();
var risultatoNotifica = form.DataSourceObject;
form.Dispose();
if (risultatoNotifica != null && risultatoNotifica.Count > 0)
{
var message = new StringBuilder();
foreach (var risultatoInvioMessaggio in risultatoNotifica)
{
if (!string.IsNullOrEmpty(risultatoInvioMessaggio.MessaggioInvio))
message.AppendLine(risultatoInvioMessaggio.MessaggioInvio);
}
CommonMessages.DisplayComplete(message.ToString());
if (Attivita.ID > 0 && risultatoNotifica.Any(item => item.InvioRiuscito))
{
Attivita = getPraticaService().GetByIdAttivita(Attivita.ID);
attivitaDTOBindingSource.DataSource = Attivita;
attivitaSource.DataSource = Attivita;
var documenti = getPraticaService().GetDocumentiByAttivita(Attivita);
_documentiUC.LoadData(documenti);
txtNote.Allegati.Clear();
txtNote.Allegati = documenti;
}
}
else
{
_log.DebugFormat("Nessun risultato per la notifica - {0} - condominio:{1} - attività:{2} - azienda:{3}", Utility.GetMethodDescription(), _condominio != null ? _condominio.ID.ToString() : "<NULL>", Attivita != null ? Attivita.ID.ToString() : "<NULL>", Security.Login.Instance.CurrentLogin().Azienda);
}
}
}
else
validationSummaryInvioMessaggio.ShowErrorSummary();
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante l'invio del messaggio - {0} - idPratica:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), _pratica.ID, Security.Login.Instance.CurrentLogin().Azienda);
throw;
}
}
private void btnTerminaClick(object sender, EventArgs e)
{
if (CommonMessages.DisplayConfirm("Sei sicuro di voler chiudere la attività?") == DialogResult.Yes)
{
var attivita = new AttivitaDTO
{
ID = Attivita.ID,
DataFineEffettiva = DateTime.Now,
IdPraticaRiferimento = Attivita.IdPraticaRiferimento
};
string message = getPraticaService().ChiusuraAttivita(attivita.ID);
if (string.IsNullOrEmpty(message))
{
var pratica = getPraticaService().GetById(Attivita.IdPraticaRiferimento);
if (getPraticaService().GetAttivitaAperteByPratica(pratica).Count == 0)
{
var dialog = CommonMessages.DisplayConfirm("La chiusura della attività è terminata correttamente" + Environment.NewLine + "La pratica non contiene più attivita aperte. Vuoi chiudere la pratica?");
if (dialog == DialogResult.Yes)
{
message = getPraticaService().Chiusura(pratica.ID);
if (string.IsNullOrEmpty(message))
CommonMessages.DisplayWarning("La chiusura della pratica è avvenuta correttamente. ");
else
CommonMessages.DisplayWarning("Si è verificato un errore. " + message);
}
}
ExecuteSave();
Close();
}
else
CommonMessages.DisplayWarning("Si è verificato un errore. " + message);
}
}
protected override bool Save()
{
if (Attivita.Stato != "")
{
AttivitaDTO attivitaInserita;
var message = getPraticaService().SaveAttivita(_pratica, Attivita, out attivitaInserita);
if (!string.IsNullOrEmpty(message))
{
CommonMessages.DisplayWarning("Si è verificato un errore: " + Environment.NewLine + message);
mainValidationSummary.Validators.Remove(reqResponsabile);
mainValidationSummary.Validators.Remove(customValidatorSoggettoAttivo);
return false;
}
Attivita = attivitaInserita;
attivitaSource.DataSource = Attivita;
BusinessClass = new BaseDTOOfint[] { Attivita };
}
base.Save();
getPraticaService().AddDocumentiAttivita(Attivita, _documenti);
_documenti.Clear();
txtNote.ReadOnly = false;
return true;
}
public string InserimentoAttivita(PraticaDTO pratica, AttivitaDTO attivitaAttuale, out AttivitaDTO attOut)
{
try
{
if (pratica != null)
{
var message = GetServiceClient().InserimentoAttivita(out attOut, attivitaAttuale, GetUserInfo());
if (string.IsNullOrEmpty(message))
pratica.Version = GetServiceClient().GetPraticaVersion(pratica.ID, GetUserInfo());
CloseService();
return message;
}
attOut = null;
return string.Empty;
}
catch (Exception ex)
{
var log = LogManager.GetLogger("Sfera");
log.ErrorFormat("Errore nell'inserimento dell'attività - {0} - pratica:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), pratica?.ID.ToString() ?? "<NULL>", Login.Instance.CurrentLogin().Azienda);
throw;
}
}
public string InserimentoAttivita(int idUtente, AttivitaDTO attivitaDto, out Attivita attOutput)
{
attOutput = null;
var message = isAllowInserimentoAttivita(attivitaDto);
try
{
if (message == "")
{
var attDao = _daoFactory.GetAttivitaDao();
var referenteDao = _daoFactory.GetReferenteDao();
var pratDao = _daoFactory.GetPraticaDao();
var responsabileRif = referenteDao.GetById(attivitaDto.IdResponsabileRiferimento, false);
var incaricato = referenteDao.Find(attivitaDto.IdIncaricato, false);
var praticaRif = pratDao.GetById(attivitaDto.IdPraticaRiferimento, false);
var inviareEmail = true;
var isNew = true;
Attivita attivita;
if (attivitaDto.ID == 0)
{
attivita = new Attivita(praticaRif, responsabileRif, incaricato, attivitaDto.DataFinePrevista, attivitaDto.AziendaID) { StatoAttivita = "Aperta" };
SetDefaultAttivita(attivita);
if (incaricato == null)
attivita.Letta = true;
}
else
{
isNew = false;
attivita = attDao.Find(attivitaDto.ID, false);
if (attivita != null)
{
attivita.ResponsabileRiferimento = responsabileRif;
attivita.Incaricato = incaricato;
attivita.DataFinePrevista = attivitaDto.DataFinePrevista;
attOutput = attivita;
}
}
if (attivita != null)
{
if (attivitaDto.IdFornitore != null)
attivita.Fornitore = _daoFactory.GetFornitoreDao().Find(attivitaDto.IdFornitore.Value, false);
attivita.AddebitoCompetenze = attivitaDto.AddebitoCompetenze;
attivita.Contrattuale = attivitaDto.Contrattuale;
attivita.Note = attivitaDto.Note;
attivita.Fatturata = attivitaDto.Fatturata;
attivita.ImportoCompetenze = attivitaDto.ImportoCompetenze;
attivita.TipoAttivitaRiferimento = attivitaDto.TipoAttivitaRiferimento;
attivita.Urgenza = (Urgenza)attivitaDto.Urgenza;
attivita.AlertScadenzaAbilitato = attivitaDto.AlertScadenzaAbilitato;
if (attivitaDto.ID == 0)
attOutput = attDao.SaveOrUpdate(attivita);
if (inviareEmail)
sendEmailToIncaricatoAttivita(attivita, isNew);
// Se presente aggiorno un eventuale nuovo messaggio
if (attivitaDto.IdNuoviMessaggi != null)
{
foreach (var id in attivitaDto.IdNuoviMessaggi)
{
var messaggio = _daoFactory.GetAttivitaMessaggioDao().Find(id, false);
if (messaggio != null)
{
messaggio.AttivitaRiferimento = attivita;
messaggio.DataInserimento = DateTime.Now;
attivita.MessaggiInviati.Add(messaggio);
}
}
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Non è stato possibile inserire la attivita. Errore durante il salvataggio delle informazioni - {0} - idAttivita:{1}", ex, Utility.GetMethodDescription(), attivitaDto.ID);
message = "Non è stato possibile inserire la attivita. Errore durante il salvataggio delle informazioni";
}
return message;
}
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 string SendEmail(AttivitaDTO attivita)
{
return SferaServiceProxy.Instance.CurrentService().ContattaResponsabileAttivita(attivita);
}
public DocumentoDTO SetDocumentoAttivita(AttivitaDTO attivita, DocumentoDTO documento)
{
documento.IdCondominio = attivita.IdCondominioRiferimento;
documento.IdAttivita = attivita.ID;
documento.Tipo = "Attivita";
if (documento.Body != null && documento.Body.Length > 0)
{
_documentoService.Save(documento,
new DocumentInfo
{
Body = documento.Body,
BodyText = null,
FileName = documento.FileName,
FileExtension = documento.FileExtension
});
}
GetServiceClient().AddDocumentiAttivita(attivita.ID, new List<int>{ documento.ID}, GetUserInfo());
CloseService();
return documento;
}
// Costruttore richiamato solo per il salvataggio di documenti relativi alle attivita
public ImportazioneDocumento(byte[] DocAttivita, string fileName, string descrizioneDocumento, AttivitaDTO attivita)
{
_docPratica = DocAttivita;
_fileName = fileName;
_attivita = attivita;
_descrizioneDocumento = descrizioneDocumento;
InitializeComponent();
this.Load += new EventHandler(ImportazioneDocumentoUI_Load);
DialogResult = DialogResult.OK;
this.Text = "Salvataggio Documento";
this.lblPrompt.Text = "Salvataggio del documento in corso.\r\nSi prega di attendere.";
}
private string isAllowInserimentoAttivita(AttivitaDTO attDto)
{
var pratica = _daoFactory.GetPraticaDao().GetById(attDto.IdPraticaRiferimento, false);
const string message = "";
if (pratica.StatoPratica == "Chiusa")
return "La pratica selezionata è stata già chiusa.";
return attDto.DataFinePrevista < pratica.DataApertura ? "La data di fine prevista per l'attività è inferiore alla data nella quale è stata aperta la pratica." : message;
}
public List<DocumentoDTO> GetByAttivita(AttivitaDTO attivita)
{
var result = GetServiceClient().GetDocumentiByAttivita(attivita.ID, GetUserInfo());
CloseService();
return result;
}
public AttivitaDTO SaveAttivita(AttivitaDTO attivita)
{
AttivitaDTO attivitaSave = attivita;
attivita.AziendaID = Gipasoft.Security.Login.Instance.CurrentLogin().Azienda;
int? idAttivita = SferaServiceProxy.Instance.CurrentService().SetAttivita(attivita);
if (idAttivita != null)
{
if (idAttivita == 0)
{
attivitaSave = new AttivitaDTO();
attivitaSave.ID = 0;
}
else
{
attivitaSave = GetByIdAttivita(idAttivita.Value);
}
}
else
attivitaSave.ID = 0;
return attivitaSave;
}
public DocumentoDTO GetNew(AttivitaDTO attivita)
{
return new DocumentoDTO { IdAttivita = attivita.ID, Tipo = "Attivita", IdCondominio = attivita.IdCondominioRiferimento };
}
public BindingList<AttivitaDTO> GetAttivitaByExample(AttivitaDTO item, int idCondominioRiferimento)
{
BindingList<AttivitaDTO> listaAttivita = GetAllAttivita();
var listAttivita = from attivita in listaAttivita
where (item.StatoAttivita == null || attivita.StatoAttivita == item.StatoAttivita) &&
(item.TipoAttivitaRiferimento == item.TipoAttivitaRiferimento) &&
(item.IdSoggettoAttivoRiferimento == 0 || attivita.IdSoggettoAttivoRiferimento == item.IdSoggettoAttivoRiferimento) &&
(item.IdResponsabileRiferimento == 0 || attivita.IdResponsabileRiferimento == item.IdResponsabileRiferimento) &&
(idCondominioRiferimento == 0 || idCondominioRiferimento == GetById(attivita.IdPraticaRiferimento).IdCondominioRiferimento)
select attivita;
if (listAttivita != null)
return new BindingList<AttivitaDTO>(listAttivita.ToList());
else
return null;
}
public string AddDocumentiAttivita(AttivitaDTO attivita, IList<DocumentoDTO> documenti)
{
if (attivita != null && documenti != null && documenti.Count > 0)
{
var result = GetServiceClient().AddDocumentiAttivita(attivita.ID, new List<int>(documenti.Select(documentoDTO => documentoDTO.ID).ToList()), GetUserInfo());
CloseService();
return result;
}
return string.Empty;
}
public string ChiusuraAttivita(AttivitaDTO attivitaInput, out AttivitaDTO attOut)
{
attOut = null;
string message = SferaServiceProxy.Instance.CurrentService().ChiusuraAttivita(out attOut, attivitaInput.ID, (DateTime)attivitaInput.DataFineEffettiva);
return message;
}
public string GetNotaAttivita(AttivitaDTO attivita)
{
var result = GetServiceClient().GetNotaAttivita(attivita.ID, GetUserInfo());
CloseService();
return result;
}
