public PraticaDTO GetSingleInstance(PraticaDTO pratica)
{
if (pratica != null && pratica.ID > 0)
return GetById(pratica.ID);
else
return pratica;
}
public DettaglioPraticaUC(PraticaDTO pratica, List<RichiedentePraticaDTO> richiedenti)
{
InitializeComponent();
Pratica = getPraticaService().GetById(pratica.ID);
inizializza();
praticaSource.DataSource = Pratica;
validationSummary1.Validators.Add(cmpDataApertura);
if (!Conversione.IsSqlSmallDateTime(Pratica.DataApertura.GetValueOrDefault()))
{
CommonMessages.DisplayWarning(string.Format("La data di apertura della pratica non è corretta.{0}Si prega di procedere alla correzione della data!", Environment.NewLine));
}
else
{
cmpDataApertura.ValueToCompare = Pratica.DataApertura.ToString();
oraDataApertura.Text = Pratica.DataApertura.GetValueOrDefault().TimeOfDay.ToString();
dataAperturaPratica.Text = Pratica.DataApertura.GetValueOrDefault().Date.ToString();
}
_richiedenti = richiedenti;
if (_richiedenti == null)
backgroundWorkerRichiedenti.RunWorkerAsync(new object[] { getPraticaService(), getCondominioService().GetById(Pratica.IdCondominioRiferimento, true), Pratica });
else
{
backgroundWorkerRichiedenti.RunWorkerAsync(new object[] { getPraticaService(), null, Pratica });
richiedentePraticaDTOBindingSource.DataSource = _richiedenti;
}
}
protected override UpdatableStandardForm getDetailForm(PraticaDTO dataSourceItem, string bandName)
{
var form = new DettaglioPraticaUI(dataSourceItem, null);
form.AfterDelete += formAfterDelete;
form.AfterUpdate += formAfterUpdate;
_forms.Add(form);
return form;
}
public void LoadData(PraticaDTO pratica)
{
_pratica = pratica;
_dataSourceAttivita = getPraticaService().GetAttivitaByPratica(_pratica);
attivitaDTOBindingSource.DataSource = _dataSourceAttivita;
lista.UpdateData();
lista.PerformAction(UltraGridAction.ExitEditMode);
}
public int GetPraticaVersion(PraticaDTO pratica)
{
if (pratica != null && pratica.ID > 0)
{
var result = GetServiceClient().GetPraticaVersion(pratica.ID, GetUserInfo());
CloseService();
return result;
}
return 0;
}
public ChiusuraAttivitaUI(PraticaDTO praticaRiferimento)
{
InitializeComponent();
_praticaService = ResolveComponent<IPraticaService>();
List<AttivitaDTO> datasource = _praticaService.GetAttivitaAperteByPratica(praticaRiferimento);
attivitaBindingSource.DataSource = datasource;
if (datasource.Count == 1)
{
cmbAttvitaAperte.SetInitialValue(datasource[0].ID, datasource[0].TipoAttivitaRiferimento);
AttivitaAperta = datasource[0].ID;
}
else validationSummary1.Validators.Add(reqAttivitaAperte);
//Aggiungo i validatori
validationSummary1.Validators.Add(reqDataChiusura);
}
public DettaglioPraticaUI(PraticaDTO pratica, List<RichiedentePraticaDTO> richiedenti)
{
try
{
InitializeComponent();
_praticaService = ResolveComponent<IPraticaService>();
_pratica = pratica;
_richiedenti = richiedenti;
inizializza();
BusinessClass = new BaseDTOOfint[] { _pratica };
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel costruttore - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Security.Login.Instance.CurrentLogin().Azienda);
throw;
}
}
private void btnApertura_Click(object sender, EventArgs e)
{
AperturaPraticaUI form = new AperturaPraticaUI();
PraticaDTO result;
if (form.ShowDialog(this) == DialogResult.OK)
{
PraticaDTO pratica = new PraticaDTO();
pratica.DataApertura = form.DataApertura;
pratica.Oggetto = form.Oggetto;
pratica.IdTipoPraticaRiferimento = form.TipoPratica;
pratica.IdPersonaRiferimento = form.Persona.ID;
pratica.IdCondominioRiferimento = form.Stabile.ID;
pratica.AziendaID = Login.Instance.CurrentLogin().Azienda;
pratica.StatoPratica = "Aperta";
result = _praticaService.AperturaPratica(pratica);
if (result != null) { }
else
CommonMessages.DisplayWarning("L'apertura della pratica non è terminata correttamente." + Environment.NewLine + "Verificare la data di apertura.");
}
}
public PraticaDTO[] GetAllPraticheByAzienda(int idAzienda)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var lista = daoFactory.GetPraticaDao().GetByAzienda(idAzienda);
var pratiche = new PraticaDTO[lista.Count];
var index = 0;
foreach (var pratica in lista)
{
pratiche[index] = setDto(pratica);
index++;
}
return pratiche;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento delle pratiche - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), idAzienda);
throw;
}
}
public string AddRichiedentePratica(PraticaDTO pratica, RichiedentePraticaDTO richiedente)
{
var richiedenti = new List<PraticaRichiedenteDTO>
{
new PraticaRichiedenteDTO
{
IdPersona = richiedente.IdPersona,
DataRichiesta = DateTime.Today,
IdPratica = pratica.ID
}
};
var result = GetServiceClient().AddRichiedentePratica(richiedenti, GetUserInfo());
CloseService();
return result;
}
public BindingList<AttivitaDTO> GetAttivitaByPratica(PraticaDTO pratica)
{
return SferaServiceProxy.Instance.CurrentService().GetAttivitaByPratica(pratica.ID);
}
public string AperturaPratica(PraticaDTO praticaAttuale, out PraticaDTO pratOut)
{
pratOut = null;
string message = SferaServiceProxy.Instance.CurrentService().AperturaPratica(out pratOut, praticaAttuale.ID, (DateTime)praticaAttuale.DataApertura, praticaAttuale.IdTipoPraticaRiferimento, praticaAttuale.IdCondominioRiferimento, praticaAttuale.IdPersonaRiferimento, praticaAttuale.Oggetto, praticaAttuale.Conformita, praticaAttuale.AziendaID);
return message;
}
public string Chiusura(PraticaDTO praticaInput, out PraticaDTO pratOut)
{
pratOut = null;
string message = SferaServiceProxy.Instance.CurrentService().ChiusuraPratica(out pratOut, praticaInput.ID, (DateTime)praticaInput.DataChiusura);
return message;
}
private bool insert(PraticaDTO dto, out Pratica item)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
var cond = daoFactory.GetCondominioDao().GetById(dto.IdCondominioRiferimento, false);
var persRif = daoFactory.GetPersonaDao().GetById(dto.IdPersonaRiferimento, false);
var tipoPratRif = daoFactory.GetTipoPraticaDao().GetById(dto.IdTipoPraticaRiferimento, false);
item = new Pratica(cond, persRif, tipoPratRif, dto.DataApertura, dto.AziendaID, null)
{
DataChiusura = dto.DataChiusura,
Oggetto = dto.Oggetto,
Conformita = dto.Conformita,
StatoPratica = dto.StatoPratica,
Urgenza = (Urgenza)dto.Urgenza
};
var rich = new PraticaRichiedente(item, persRif, dto.DataApertura.GetValueOrDefault()) {Note = "Apertura"};
daoFactory.GetPraticaRichiedenteDao().SaveOrUpdate(rich);
item.Richiedenti.Add(rich);
daoFactory.GetPraticaDao().SaveOrUpdate(item);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'inserimento delle pratiche - {0} - id:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), dto.ID, _info.Azienda);
throw;
}
return true;
}
public List<AttivitaDTO> GetAttivitaByPratica(PraticaDTO pratica)
{
var result = GetServiceClient().GetAttivitaByPratica(pratica.ID, GetUserInfo());
CloseService();
return result;
}
void listaAttivitaPraticaClosed(object sender, PraticaClosedArgs e)
{
Pratica = getPraticaService().GetById(e.IdPratica);
praticaSource.DataSource = Pratica;
Save();
OnAfterUpdate(new DataSourceEventArgs<PraticaDTO>(Pratica));
}
private Pratica managePratica(PraticaDTO praticaDto)
{
Pratica prat = null;
bool result;
// Controllo sullo stato U, D, I
switch (praticaDto.Stato.ToUpper())
{
case "U":
result = update(praticaDto, out prat);
if (!result)
{
//Il dato sul database è più recente di quello utilizzato
prat = null;
}
break;
case "I":
result = insert(praticaDto, out prat);
if (!result)
throw new Exception("Impossibile scrivere sul database");
break;
}
return prat;
}
public bool Save()
{
Pratica.Stato = "U";
if (Pratica.Stato != "")
{
if (sceltaPersonaCombo1.SelectedPersona != null)
Pratica.IdPersonaRiferimento = sceltaPersonaCombo1.SelectedPersona.ID;
var pratica = getPraticaService().Save(Pratica);
if (pratica.ID == 0)
{
CommonMessages.DisplayWarning("Si è verificato un errore: un altro utente ha effettuato un aggiornamento. Uscire e riprovare ");
Dispose();
}
else
{
Pratica = pratica;
praticaSource.DataSource = Pratica;
var ver = pratica.Version;
if (ver != 0)
Pratica.Version = ver;
}
}
return true;
}
public List<RichiedentePraticaDTO> GetAllSoggettiFornitori(CondominioDTO condominio, PraticaDTO pratica)
{
//IList<RichiedentePraticaDTO> fornitoriPreferiti = (from fornitore in _fornitoreService.GetPreferitiByCondominio(condominio.ID)
// select new RichiedentePraticaDTO()
// {
// Id = fornitore.ID,
// DisplayNominativo = fornitore.PersonaRiferimento.DisplayName,
// IdCondominio = condominio.ID,
// IdPersona = fornitore.PersonaRiferimento.ID,
// Tipo = "Fornitore"
// }).ToList();
//IList<RichiedentePraticaDTO> soggetti = (from soggetto in _soggettoService.GetByCondominio(condominio)
// select new RichiedentePraticaDTO()
// {
// Id = soggetto.ID,
// DisplayNominativo = soggetto.DisplayNominativo,
// DescrizioneUnitaImmobiliare = soggetto.DescrizioneUnitaImmobiliare,
// IdCondominio = condominio.ID,
// IdPersona = soggetto.IdPersona,
// IdUnitaImmobiliare = soggetto.IdUnitaImmobiliare,
// OrdineUnitaImmobiliare = soggetto.OrdineUnitaImmobiliare,
// Tipo = soggetto.Tipo.ToString()
// }).ToList();
//ISet<RichiedentePraticaDTO> richiedenti = new HashedSet<RichiedentePraticaDTO>(soggetti);
//richiedenti.AddAll(fornitoriPreferiti);
//return new List<RichiedentePraticaDTO>(richiedenti.ToList());
int? idPratica = null;
if (pratica != null)
idPratica = pratica.ID;
var result = GetServiceClient().GetAllRichiedentiPraticaCondominio(condominio.ID, idPratica, GetUserInfo());
CloseService();
return result;
}
public List<DocumentoDTO> GetDocumentiByPratica(PraticaDTO pratica)
{
return _documentoService.GetByPratica(pratica);
}
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 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 int? ManageDomainEntity(PraticaDTO praticaDto)
{
try
{
Pratica pratica = managePratica(praticaDto);
if (pratica != null)
return pratica.ID;
return null;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella gestione della pratica - {0} - id:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), praticaDto.ID, _info.Azienda);
throw;
}
}
public List<PraticaRichiedenteDTO> GetRichiedentiPratica(PraticaDTO pratica)
{
try
{
var result = GetServiceClient().GetRichiedentiPratica(pratica.ID, GetUserInfo());
CloseService();
return result;
}
catch (CommunicationObjectAbortedException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (CommunicationObjectFaultedException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (CommunicationException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (IOException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (ObjectDisposedException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento dei richiedentii della pratica - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
return new List<PraticaRichiedenteDTO>();
}
private PraticaDTO setDto(Pratica item)
{
var dto = new PraticaDTO
{
Conformita = item.Conformita,
NumDocumenti = item.Documenti.Count,
DataApertura = item.DataApertura,
DataChiusura = item.DataChiusura,
Oggetto = item.Oggetto,
StatoPratica = item.StatoPratica,
Urgenza = (int)item.Urgenza,
ID = item.ID,
Version = item.Version
};
if (item.CondominioRiferimento != null)
{
dto.DisplayName = item.CondominioRiferimento.DisplayName + " - " + item.TipoPraticaRiferimento.Descrizione;
if (!string.IsNullOrWhiteSpace(dto.Oggetto))
dto.DisplayName += " - " + item.Oggetto;
dto.IdCondominioRiferimento = item.CondominioRiferimento.ID;
dto.DescrizioneCondominioRiferimento = item.CondominioRiferimento.Codice + " - " + item.CondominioRiferimento.Descrizione;
}
if (item.TipoPraticaRiferimento != null)
{
dto.IdTipoPraticaRiferimento = item.TipoPraticaRiferimento.ID;
dto.DescrizioneTipoPraticaRiferimento = item.TipoPraticaRiferimento.Descrizione;
}
if (item.PersonaRiferimento != null)
{
dto.IdPersonaRiferimento = item.PersonaRiferimento.ID;
var richiedenti = new HashSet<Persona> {item.PersonaRiferimento};
foreach (var rich in item.Richiedenti)
richiedenti.Add(rich.Richiedente);
foreach (var persona in richiedenti)
{
if (!string.IsNullOrEmpty(dto.NominativoPersona))
dto.NominativoPersona += " - ";
dto.NominativoPersona += persona.DisplayName;
}
}
if (item.AziendaID != null)
dto.AziendaID = (int)item.AziendaID;
return dto;
}
public PraticaDTO Save(PraticaDTO pratica)
{
PraticaDTO praticaSave = pratica;
pratica.AziendaID = Gipasoft.Security.Login.Instance.CurrentLogin().Azienda;
int? idPratica = SferaServiceProxy.Instance.CurrentService().SetPratica(pratica);
if (idPratica != null)
{
if (idPratica == 0)
{
praticaSave = new PraticaDTO();
praticaSave.ID = 0;
}
else
{
praticaSave = GetById(idPratica.Value);
}
}
else
praticaSave.ID = 0;
return praticaSave;
}
private bool update(PraticaDTO dto, out Pratica item)
{
var result = false;
item = null;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
item = daoFactory.GetPraticaDao().Find(dto.ID, false);
// Condizione necessare per il controllo del fatto che sul DB ho una versione uguale o più vecchia
if (item != null)
{
// Per ora non viene controllato un eventuale problema di concorrenza
if (dto.Version == item.Version || true)
{
item.CondominioRiferimento = daoFactory.GetCondominioDao().GetById(dto.IdCondominioRiferimento, false);
item.TipoPraticaRiferimento = daoFactory.GetTipoPraticaDao().GetById(dto.IdTipoPraticaRiferimento, false);
item.PersonaRiferimento = daoFactory.GetPersonaDao().GetById(dto.IdPersonaRiferimento, false);
item.Oggetto = dto.Oggetto;
item.DataApertura = dto.DataApertura;
item.StatoPratica = dto.StatoPratica;
item.Conformita = dto.Conformita;
item.Urgenza = (Urgenza) dto.Urgenza;
daoFactory.GetPraticaDao().Update(item);
result = true;
}
else
{
// Eccezione: Sul db c'è qualche cosa di più nuovo.
_log.ErrorFormat("Errore nel salvataggio delle pratiche: id:{0} - il dato sul db è più recente di quello che si vuole salvare", dto.ID);
}
}
else
result = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio delle pratiche - {0} - id:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), dto.ID, _info.Azienda);
throw;
}
return result;
}
public void DeletePratica(PraticaDTO pratica)
{
if (SferaServiceProxy.Instance.CurrentService().DeletePratica(pratica.ID));
}
public void New()
{
try
{
Hide();
var form = new InserimentoPraticaUI();
if (form.ShowDialog(this) == DialogResult.OK)
{
try
{
Pratica = new PraticaDTO
{
DataApertura = form.DataApertura,
Oggetto = form.Oggetto,
IdTipoPraticaRiferimento = form.TipoPratica,
IdPersonaRiferimento = form.Richiedente != null ? form.Richiedente.IdPersona : 0,
IdCondominioRiferimento = form.Condominio.ID,
AziendaID = Login.Instance.CurrentLogin().Azienda,
StatoPratica = "Aperta",
Conformita = form.Conformita
};
}
catch (Exception ex)
{
_log.ErrorFormat("Nuova pratica - {0} - dataApertura:{1} - oggetto:{2} - tipoPratica:{3} - idPersona:{4} - condominio:{5} - conformita:{6} - azienda:{7}", ex, Utility.GetMethodDescription(), form.DataApertura, form.Oggetto, form.TipoPratica, form.Richiedente != null ? form.Richiedente.IdPersona.ToString(CultureInfo.InvariantCulture) : "<NULL>", form.Condominio != null ? form.Condominio.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>", form.Conformita.GetValueOrDefault(), Login.Instance.CurrentLogin().Azienda);
throw;
}
PraticaDTO pratOut;
var message = getPraticaService().AperturaPratica(Pratica, out pratOut);
Pratica = pratOut;
if (Pratica != null && string.IsNullOrEmpty(message))
{
try
{
CommonMessages.DisplayComplete("L'apertura della pratica è terminata correttamente. " + Environment.NewLine + "E' ora possibile inserire una nuova attivita");
inserisciAttivita();
var dettaglio = new DettaglioPraticaUI(Pratica, _richiedenti);
dettaglio.ShowDialog();
dettaglio.Dispose();
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'apertura di una nuova pratica - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
throw;
}
}
else
CommonMessages.DisplayWarning("Si è verificato un errore. " + message);
}
form.Dispose();
}
catch (Exception ex)
{
_log.ErrorFormat("Nuova pratica - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
throw;
}
}
public DocumentoDTO SetDocumento(PraticaDTO pratica, DocumentoDTO documento)
{
documento.IdCondominio = pratica.IdCondominioRiferimento;
documento.IdPratica = pratica.ID;
documento.Tipo = "Pratica";
return documento;
}
