public DettaglioAssicurazioneGlobaleUI(CondominioDTO stabile, AssicurazioneContrattoDTO contratto, bool disableEditing) : base(stabile, contratto, disableEditing)
{
InitializeComponent();
inizializza();
bindingAssicurazioneContrattoDTO.DataSource = Contratto;
}
public DettaglioAssicurazioneGlobaleUI(AssicurazioneContrattoDTO contrattoCache) : base(contrattoCache)
{
InitializeComponent();
inizializza();
bindingAssicurazioneContrattoDTO.DataSource = Contratto;
}
public void LoadData(AssicurazioneContrattoDTO contratto)
{
_contratto = contratto;
premioAssicurativoDTOBindingSource.DataSource = _contratto.PremiPagati;
if (_contratto != null && _contratto.ImportoPremio != null)
lista.DisplayLayout.Bands[0].Columns["ImportoPagamento"].DefaultCellValue = _contratto.ImportoPremio;
}
public DettaglioAssicurazioneContrattoUI(ContrattoListaDTO contrattoCache)
{
InitializeComponent();
inizializza();
_contratto = _contrattoService.GetById(contrattoCache.ID.GetValueOrDefault());
assicurazioneContrattoDtoBindingSource.DataSource = _contratto;
BusinessClass = new BaseDTOOfint[] { _contratto };
}
public DettaglioAssicurazioneContrattoUI(CondominioDTO condominio, AssicurazioneContrattoDTO contratto, bool disableEditing) : base(disableEditing)
{
InitializeComponent();
inizializza();
_condominio = condominio;
_contratto = contratto;
IsNew = true;
}
public ListaPremiAssicurativiUC(AssicurazioneContrattoDTO contratto, LoginInfo currentUser)
{
InitializeComponent();
if (!DesignMode)
{
inizializza();
if (contratto != null)
{
LoadData(contratto);
}
}
}
public AssicurazioneContrattoDTO Save(AssicurazioneContrattoDTO contratto)
{
var contrattoSave = new AssicurazioneContrattoDTO();
var idContratto = GetServiceClient().SetAssicurazioneContratto(contratto, GetUserInfo());
if (idContratto != null)
{
if (idContratto == 0)
{
contrattoSave = new AssicurazioneContrattoDTO {ID = 0};
}
else
{
contratto.ID = (int)idContratto;
contrattoSave = GetById(contratto.ID);
}
}
else
contrattoSave.ID = 0;
CloseService();
return contrattoSave;
}
public AssicurazioneContrattoDTO[] GetAllacByAzienda(int idAzienda)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var lista = daoFactory.GetAssicurazioneContrattoDao().GetByAzienda(idAzienda);
var assicurazioniContratti = new AssicurazioneContrattoDTO[lista.Count];
var index = 0;
foreach (var assicurazioneContratto in lista)
{
assicurazioniContratti[index] = setAssicurazioniContrattiDto(assicurazioneContratto);
index++;
}
return assicurazioniContratti;
}
catch (Exception ex)
{
_log.Error("Errore nel caricamento dei Contratti Assicurativi: " + Utility.GetMethodDescription(), ex);
throw;
}
}
public AssicurazioneContrattoDTO Pagamento(AssicurazioneContrattoDTO contratto, DateTime data, decimal importo)
{
var result = GetServiceClient().PagamentoPremioAssicurativo(contratto.ID, data, importo, GetUserInfo());
CloseService();
return result;
}
private bool insertAssicurazioneContratto(AssicurazioneContrattoDTO assicurazioneContrattoDto, out AssicurazioneContratto assc)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
bool result;
var tipo = daoFactory.GetTipoContrattoDao().Find(assicurazioneContrattoDto.IdTipoContratto.GetValueOrDefault(), false);
if(tipo == null)
_log.ErrorFormat("Non trovato il tipo contratto assicurativo - {0} - tipo:{1} - azienda:{2}", Utility.GetMethodDescription(), assicurazioneContrattoDto.IdTipoContratto.GetValueOrDefault(), _info.Azienda);
try
{
switch(assicurazioneContrattoDto.Tipo)
{
case TipoPolizza.GlobaleFabbricati:
assc = new GlobaleAssicurazione(assicurazioneContrattoDto.Scadenza, assicurazioneContrattoDto.ScadenzaPremio, tipo);
((GlobaleAssicurazione)assc).DanniAcqua = assicurazioneContrattoDto.DanniAcqua;
((GlobaleAssicurazione)assc).FranchigiaDanniAcqua = assicurazioneContrattoDto.FranchigiaDanniAcqua;
((GlobaleAssicurazione)assc).FranchigiaRicercaGuasto = assicurazioneContrattoDto.FranchigiaRicercaGuasto;
((GlobaleAssicurazione)assc).ImportoLimiteCoseRCT = assicurazioneContrattoDto.ImportoLimiteCoseRCT;
((GlobaleAssicurazione)assc).ImportoMassimaleSinistroRCT = assicurazioneContrattoDto.ImportoMassimaleSinistroRCT;
((GlobaleAssicurazione)assc).ImportoUnicoRCT = assicurazioneContrattoDto.ImportoUnicoRCT;
((GlobaleAssicurazione)assc).RicercaGuasto = assicurazioneContrattoDto.RicercaGuasto;
((GlobaleAssicurazione)assc).ValoreRicostruzioneNuovo = assicurazioneContrattoDto.ValoreRicostruzioneNuovo;
((GlobaleAssicurazione)assc).ImportoLimitePersonaRCT = assicurazioneContrattoDto.ImportoLimitePersonaRCT;
break;
case TipoPolizza.Incendio:
assc = new IncendioAssicurazione(assicurazioneContrattoDto.Scadenza, assicurazioneContrattoDto.ScadenzaPremio, tipo);
((IncendioAssicurazione)assc).DanniAcqua = assicurazioneContrattoDto.DanniAcqua;
((IncendioAssicurazione)assc).FranchigiaDanniAcqua = assicurazioneContrattoDto.FranchigiaDanniAcqua;
((IncendioAssicurazione)assc).FranchigiaRicercaGuasto = assicurazioneContrattoDto.FranchigiaRicercaGuasto;
((IncendioAssicurazione)assc).ImportoLimiteCoseRCT = assicurazioneContrattoDto.ImportoLimiteCoseRCT;
((IncendioAssicurazione)assc).ImportoMassimaleSinistroRCT = assicurazioneContrattoDto.ImportoMassimaleSinistroRCT;
((IncendioAssicurazione)assc).ImportoUnicoRCT = assicurazioneContrattoDto.ImportoUnicoRCT;
((IncendioAssicurazione)assc).RicercaGuasto = assicurazioneContrattoDto.RicercaGuasto;
((IncendioAssicurazione)assc).ValoreRicostruzioneNuovo = assicurazioneContrattoDto.ValoreRicostruzioneNuovo;
((IncendioAssicurazione)assc).ImportoLimitePersonaRCT = assicurazioneContrattoDto.ImportoLimitePersonaRCT;
break;
case TipoPolizza.Furto:
assc = new FurtoAssicurazione(assicurazioneContrattoDto.Scadenza, assicurazioneContrattoDto.ScadenzaPremio, tipo);
break;
case TipoPolizza.Infortuni:
assc = new InfortuniAssicurazione(assicurazioneContrattoDto.Scadenza, assicurazioneContrattoDto.ScadenzaPremio, tipo);
break;
case TipoPolizza.ResponsabilitaCivile:
assc = new ResponsabilitaCivileAssicurazione(assicurazioneContrattoDto.Scadenza, assicurazioneContrattoDto.ScadenzaPremio, tipo);
break;
default:
assc = new AssicurazioneContratto(assicurazioneContrattoDto.Scadenza, assicurazioneContrattoDto.ScadenzaPremio, tipo);
break;
}
// Save Or Update immediato per ottenere subito l'ID del contratto
daoFactory.GetAssicurazioneContrattoDao().SaveOrUpdate(assc);
assc.AlertPremioAbilitato = assicurazioneContrattoDto.AlertPremioAbilitato;
assc.AlertScadenzaAbilitato = assicurazioneContrattoDto.AlertScadenzaAbilitato;
assc.Descrizione = assicurazioneContrattoDto.Descrizione;
assc.ImportoPremio = assicurazioneContrattoDto.ImportoPremio;
assc.MesiDurata = assicurazioneContrattoDto.MesiDurata;
assc.Note = assicurazioneContrattoDto.Note;
assc.PresenzaAppalto = assicurazioneContrattoDto.PresenzaAppalto;
assc.NumeroContratto = assicurazioneContrattoDto.NumeroPolizza;
// -------------------------------------
// Alert Premio
// -------------------------------------
foreach (AlertContrattoDTO t in assicurazioneContrattoDto.AlertPremio)
{
if (t != null)
{
int? id = t.ID;
if (t.Stato.ToUpper() == "U" || t.Stato.ToUpper() == "I")
id = getAlertRepository().ManageDomainEntity(t);
var alert = daoFactory.GetAlertPremioContrattoDao().GetById(id.GetValueOrDefault(), false);
assc.AlertPremio.Add(alert);
alert.ContrattoAssicurativoRiferimento = assc;
}
}
// -------------------------------------
// Alert Scadenza
// -------------------------------------
foreach (AlertContrattoDTO t in assicurazioneContrattoDto.AlertScadenza)
{
if (t != null)
{
int? id = t.ID;
if (t.Stato.ToUpper() == "U" || t.Stato.ToUpper() == "I")
id = getAlertRepository().ManageDomainEntity(t);
var alert = daoFactory.GetAlertScadenzaContrattoDao().GetById(id.GetValueOrDefault(), false);
assc.AlertScadenza.Add(alert);
alert.ContrattoRiferimento = assc;
}
}
// -------------------------------------
// Condominio Riferimento
// -------------------------------------
if (assicurazioneContrattoDto.IdCondominio != null && assicurazioneContrattoDto.IdCondominio > 0)
{
assc.CondominioRiferimento = daoFactory.GetCondominioDao().Find(assicurazioneContrattoDto.IdCondominio.Value, false);
}
// -------------------------------------
// Fornitore
// -------------------------------------
if (assicurazioneContrattoDto.IdFornitore != null && assicurazioneContrattoDto.IdFornitore > 0)
{
assc.FornitoreAttuale = daoFactory.GetFornitoreDao().Find(assicurazioneContrattoDto.IdFornitore.Value, false);
}
// -------------------------------------
// Tipo
// -------------------------------------
if (assicurazioneContrattoDto.IdTipoContratto != null && assicurazioneContrattoDto.IdTipoContratto > 0)
{
assc.Tipo = daoFactory.GetTipoContrattoDao().Find(assicurazioneContrattoDto.IdTipoContratto.Value, false);
}
// -------------------------------------
// Documenti
// -------------------------------------
assc.Documenti.Clear();
foreach (var t in assicurazioneContrattoDto.Documenti)
{
if (t != null)
{
t.IdContratto = assc.ID;
int? id = t.ID;
if (t.Stato.ToUpper() == "U" || t.Stato.ToUpper() == "I")
id = getDocumentoRepository().ManageDomainEntity(t, assc.CondominioRiferimento.Azienda.ID);
assc.Documenti.Add(daoFactory.GetDocumentoDao().GetById(id.Value, false));
}
}
// -------------------------------------
// Premi Pagati
// -------------------------------------
assc.PremiPagati.Clear();
foreach (var t in assicurazioneContrattoDto.PremiPagati)
{
if (t != null)
{
t.IdContratto = assc.ID;
int? id = t.ID;
if (t.Stato.ToUpper() == "U" || t.Stato.ToUpper() == "I")
id = getPremioAssicurativoRepository().ManageDomainEntity(t);
assc.PremiPagati.Add(daoFactory.GetPremioAssicurativoDao().GetById(id.Value, false));
}
}
result = true;
}
catch (Exception ex)
{
_log.Error("Errore nell'inserimento del contratto assicurativo: " + Utility.GetMethodDescription() + " - id:" + assicurazioneContrattoDto.ID, ex);
throw;
}
return result;
}
private bool updateAssicurazioneContratto(AssicurazioneContrattoDTO assicurazioneContrattoDto, out AssicurazioneContratto assc)
{
bool result;
assc = null;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
assc = daoFactory.GetAssicurazioneContrattoDao().Find(assicurazioneContrattoDto.ID, false);
// Condizione necessare per il controllo del fatto che sul DB ho una versione uguale o più vecchia
if (assc != null && assicurazioneContrattoDto.Version == assc.Version)
{
if (Conversione.IsTypeOf(assc, typeof(GlobaleAssicurazione)))
{
((GlobaleAssicurazione)assc).DanniAcqua = assicurazioneContrattoDto.DanniAcqua;
((GlobaleAssicurazione)assc).FranchigiaDanniAcqua = assicurazioneContrattoDto.FranchigiaDanniAcqua;
((GlobaleAssicurazione)assc).FranchigiaRicercaGuasto = assicurazioneContrattoDto.FranchigiaRicercaGuasto;
((GlobaleAssicurazione)assc).ImportoLimiteCoseRCT = assicurazioneContrattoDto.ImportoLimiteCoseRCT;
((GlobaleAssicurazione)assc).ImportoMassimaleSinistroRCT = assicurazioneContrattoDto.ImportoMassimaleSinistroRCT;
((GlobaleAssicurazione)assc).ImportoUnicoRCT = assicurazioneContrattoDto.ImportoUnicoRCT;
((GlobaleAssicurazione)assc).RicercaGuasto = assicurazioneContrattoDto.RicercaGuasto;
((GlobaleAssicurazione)assc).ValoreRicostruzioneNuovo = assicurazioneContrattoDto.ValoreRicostruzioneNuovo;
((GlobaleAssicurazione)assc).ImportoLimitePersonaRCT = assicurazioneContrattoDto.ImportoLimitePersonaRCT;
}
else if (Conversione.IsTypeOf(assc, typeof(IncendioAssicurazione)))
{
((IncendioAssicurazione)assc).DanniAcqua = assicurazioneContrattoDto.DanniAcqua;
((IncendioAssicurazione)assc).FranchigiaDanniAcqua = assicurazioneContrattoDto.FranchigiaDanniAcqua;
((IncendioAssicurazione)assc).FranchigiaRicercaGuasto = assicurazioneContrattoDto.FranchigiaRicercaGuasto;
((IncendioAssicurazione)assc).ImportoLimiteCoseRCT = assicurazioneContrattoDto.ImportoLimiteCoseRCT;
((IncendioAssicurazione)assc).ImportoMassimaleSinistroRCT = assicurazioneContrattoDto.ImportoMassimaleSinistroRCT;
((IncendioAssicurazione)assc).ImportoUnicoRCT = assicurazioneContrattoDto.ImportoUnicoRCT;
((IncendioAssicurazione)assc).RicercaGuasto = assicurazioneContrattoDto.RicercaGuasto;
((IncendioAssicurazione)assc).ValoreRicostruzioneNuovo = assicurazioneContrattoDto.ValoreRicostruzioneNuovo;
((IncendioAssicurazione)assc).ImportoLimitePersonaRCT = assicurazioneContrattoDto.ImportoLimitePersonaRCT;
}
assc.AlertPremioAbilitato = assicurazioneContrattoDto.AlertPremioAbilitato;
assc.AlertScadenzaAbilitato = assicurazioneContrattoDto.AlertScadenzaAbilitato;
assc.Descrizione = assicurazioneContrattoDto.Descrizione;
assc.ImportoPremio = assicurazioneContrattoDto.ImportoPremio;
assc.MesiDurata = assicurazioneContrattoDto.MesiDurata;
assc.Note = assicurazioneContrattoDto.Note;
assc.PresenzaAppalto = assicurazioneContrattoDto.PresenzaAppalto;
assc.Scadenza = assicurazioneContrattoDto.Scadenza;
assc.ScadenzaPremio = assicurazioneContrattoDto.ScadenzaPremio;
assc.NumeroContratto = assicurazioneContrattoDto.NumeroPolizza;
// -------------------------------------
// Alert Premio
// -------------------------------------
assc.AlertPremio.Clear();
foreach (var t in assicurazioneContrattoDto.AlertPremio)
{
if (t != null)
{
int? id = t.ID;
if (t.Stato.ToUpper() == "U" || t.Stato.ToUpper() == "I")
id = getAlertRepository().ManageDomainEntity(t);
var alert = daoFactory.GetAlertPremioContrattoDao().Find(id.GetValueOrDefault(), false);
if (alert != null)
{
assc.AlertPremio.Add(alert);
alert.ContrattoRiferimento = assc;
}
}
}
// -------------------------------------
// Alert Scadenza
// -------------------------------------
assc.AlertScadenza.Clear();
foreach (var t in assicurazioneContrattoDto.AlertScadenza)
{
if (t != null)
{
int? id = t.ID;
if (t.Stato.ToUpper() == "U" || t.Stato.ToUpper() == "I")
id = getAlertRepository().ManageDomainEntity(t);
var alert = daoFactory.GetAlertScadenzaContrattoDao().Find(id.GetValueOrDefault(), false);
if (alert != null)
{
assc.AlertScadenza.Add(alert);
alert.ContrattoRiferimento = assc;
}
}
}
// -------------------------------------
// Condominio Riferimento
// -------------------------------------
if (assicurazioneContrattoDto.IdCondominio != null && assicurazioneContrattoDto.IdCondominio > 0)
{
assc.CondominioRiferimento = daoFactory.GetCondominioDao().GetById(assicurazioneContrattoDto.IdCondominio.Value, false);
}
// -------------------------------------
// Fornitore
// -------------------------------------
if (assicurazioneContrattoDto.IdFornitore != null && assicurazioneContrattoDto.IdFornitore > 0)
{
assc.FornitoreAttuale = daoFactory.GetFornitoreDao().Find(assicurazioneContrattoDto.IdFornitore.Value, false);
}
// -------------------------------------
// Tipo
// -------------------------------------
if (assicurazioneContrattoDto.IdTipoContratto != null && assicurazioneContrattoDto.IdTipoContratto > 0)
{
assc.Tipo = daoFactory.GetTipoContrattoDao().Find(assicurazioneContrattoDto.IdTipoContratto.Value, false);
}
// -------------------------------------
// Documenti
// -------------------------------------
assc.Documenti.Clear();
foreach (var t in assicurazioneContrattoDto.Documenti)
{
if (t != null)
{
int? id = t.ID;
if (t.Stato.ToUpper() == "U" || t.Stato.ToUpper() == "I")
id = getDocumentoRepository().ManageDomainEntity(t, assc.CondominioRiferimento.Azienda.ID);
assc.Documenti.Add(daoFactory.GetDocumentoDao().Find(id.Value, false));
}
}
// -------------------------------------
// Premi Pagati
// -------------------------------------
assc.PremiPagati.Clear();
foreach (var t in assicurazioneContrattoDto.PremiPagati)
{
if (t != null)
{
int? id = t.ID;
t.IdContratto = assc.ID;
if (t.Stato.ToUpper() == "U" || t.Stato.ToUpper() == "I")
id = getPremioAssicurativoRepository().ManageDomainEntity(t);
var premio = daoFactory.GetPremioAssicurativoDao().Find(id.Value, false);
if (premio != null)
{
assc.PremiPagati.Add(premio);
premio.ContrattoRiferimento = assc;
}
}
}
daoFactory.GetAssicurazioneContrattoDao().Update(assc);
result = true;
}
else
{
// Eccezione: Sul db c'è qualche cosa di più nuovo.
_log.ErrorFormat("Errore nel salvataggio del contratto appalto - Il dato sul db è più recente di quello che si vuole salvare - {0} - id:{1}", Utility.GetMethodDescription(), assicurazioneContrattoDto.ID);
result = false;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio del contratto assicurativo - {0} - id:{1} ", ex, Utility.GetMethodDescription(), assicurazioneContrattoDto.ID);
throw;
}
return result;
}
private AssicurazioneContrattoDTO setAssicurazioniContrattiDto(AssicurazioneContratto item)
{
try
{
if (item != null)
{
var dto = new AssicurazioneContrattoDTO {Note = item.Note};
if (Conversione.IsTypeOf(item, typeof (GlobaleAssicurazione)))
{
dto.Tipo = TipoPolizza.GlobaleFabbricati;
dto.DanniAcqua = ((GlobaleAssicurazione) item).DanniAcqua;
dto.FranchigiaDanniAcqua = ((GlobaleAssicurazione) item).FranchigiaDanniAcqua;
dto.FranchigiaRicercaGuasto = ((GlobaleAssicurazione) item).FranchigiaRicercaGuasto;
dto.ImportoLimiteCoseRCT = ((GlobaleAssicurazione) item).ImportoLimiteCoseRCT;
dto.ImportoMassimaleSinistroRCT = ((GlobaleAssicurazione) item).ImportoMassimaleSinistroRCT;
dto.ImportoUnicoRCT = ((GlobaleAssicurazione) item).ImportoUnicoRCT;
dto.RicercaGuasto = ((GlobaleAssicurazione) item).RicercaGuasto;
dto.ValoreRicostruzioneNuovo = ((GlobaleAssicurazione) item).ValoreRicostruzioneNuovo;
dto.ImportoLimitePersonaRCT = ((GlobaleAssicurazione) item).ImportoLimitePersonaRCT;
}
else if (Conversione.IsTypeOf(item, typeof (FurtoAssicurazione)))
{
dto.Tipo = TipoPolizza.Furto;
dto.DescrizioneTipo = item.DescrizioneTipo;
}
else if (Conversione.IsTypeOf(item, typeof (IncendioAssicurazione)))
{
dto.Tipo = TipoPolizza.Incendio;
dto.DanniAcqua = ((IncendioAssicurazione) item).DanniAcqua;
dto.FranchigiaDanniAcqua = ((IncendioAssicurazione) item).FranchigiaDanniAcqua;
dto.FranchigiaRicercaGuasto = ((IncendioAssicurazione) item).FranchigiaRicercaGuasto;
dto.ImportoLimiteCoseRCT = ((IncendioAssicurazione) item).ImportoLimiteCoseRCT;
dto.ImportoMassimaleSinistroRCT = ((IncendioAssicurazione) item).ImportoMassimaleSinistroRCT;
dto.ImportoUnicoRCT = ((IncendioAssicurazione) item).ImportoUnicoRCT;
dto.RicercaGuasto = ((IncendioAssicurazione) item).RicercaGuasto;
dto.ValoreRicostruzioneNuovo = ((IncendioAssicurazione) item).ValoreRicostruzioneNuovo;
dto.ImportoLimitePersonaRCT = ((IncendioAssicurazione) item).ImportoLimitePersonaRCT;
}
else if (Conversione.IsTypeOf(item, typeof (InfortuniAssicurazione)))
{
dto.Tipo = TipoPolizza.Incendio;
dto.DescrizioneTipo = item.DescrizioneTipo;
}
else if (Conversione.IsTypeOf(item, typeof (ResponsabilitaCivileAssicurazione)))
dto.Tipo = TipoPolizza.ResponsabilitaCivile;
else
dto.Tipo = TipoPolizza.Undefined;
dto.ImportoPremio = item.ImportoPremio;
dto.AnniDurata = item.AnniDurata;
dto.Descrizione = item.Descrizione;
dto.AlertScadenzaAbilitato = item.AlertScadenzaAbilitato;
dto.AlertPremioAbilitato = item.AlertPremioAbilitato;
dto.DescrizioneTipo = item.DescrizioneTipo;
dto.DisplayName = item.DisplayName;
dto.NumeroPolizza = item.NumeroContratto;
dto.ID = item.ID;
dto.Version = item.Version;
var ultimoPagato = item.GetUltimoPremioPagato();
if (ultimoPagato != null)
{
if (ultimoPagato.DataPagamento != null)
dto.DataPagamentoPremio = ultimoPagato.DataPagamento.Value;
if (ultimoPagato.Importo != null)
dto.UltimoPremioPagato = ultimoPagato.Importo.Value;
}
// --------------------------------------------------------
// Alert scadenza contratto
// --------------------------------------------------------
var indexAlertScadenza = 0;
var repAlert = new AlertContrattoRepository(_info, _windsorRepository);
foreach (var alertScadenza in item.AlertScadenza)
{
if (dto.AlertScadenza.Length == 0)
dto.AlertScadenza = new AlertContrattoDTO[item.AlertScadenza.Count];
dto.AlertScadenza[indexAlertScadenza] = repAlert.GetByDomainEntity(alertScadenza);
indexAlertScadenza++;
}
// --------------------------------------------------------
// Alert premio contratto
// --------------------------------------------------------
var indexAlertPremio = 0;
foreach (AlertPremioContratto alertPremio in item.AlertPremio)
{
if (dto.AlertPremio.Length == 0)
dto.AlertPremio = new AlertContrattoDTO[item.AlertPremio.Count];
dto.AlertPremio[indexAlertPremio] = repAlert.GetByDomainEntity(alertPremio);
indexAlertPremio++;
}
if (item.MesiDurata != null)
dto.MesiDurata = item.MesiDurata.Value;
if (item.Scadenza != null)
dto.Scadenza = item.Scadenza.Value;
if (item.ScadenzaPremio != null)
dto.ScadenzaPremio = item.ScadenzaPremio.Value;
dto.TipologiaContratto = TipoContrattoEnum.ContrattoAssicurativo;
if (item.Tipo != null)
{
dto.IdTipoContratto = item.Tipo.ID;
dto.DisplayTipoContratto = item.Tipo.Descrizione;
}
if (item.FornitoreAttuale != null)
{
dto.IdFornitore = item.FornitoreAttuale.ID;
dto.DisplayFornitore = item.FornitoreAttuale.DisplayName;
}
if (item.CondominioRiferimento != null)
{
dto.IdCondominio = item.CondominioRiferimento.ID;
dto.DisplayCondominio = item.CondominioRiferimento.DisplayName;
}
// --------------------------------------------------------
// Premi
// --------------------------------------------------------
var indexPremio = 0;
var repPremio = new PremioAssicurativoRepository(_info, _windsorRepository);
foreach (var premio in item.PremiPagati)
{
if (dto.PremiPagati.Length == 0)
dto.PremiPagati = new PremioAssicurativoDTO[item.PremiPagati.Count];
dto.PremiPagati[indexPremio] = repPremio.GetByDomainEntity(premio);
indexPremio++;
}
// -----------------------------------
// Documenti
// -----------------------------------
var indexDocumenti = 0;
foreach (var documento in item.Documenti)
{
var docDto = getDocumentoRepository().GetByDomainEntity(documento);
if (dto.Documenti.Length == 0)
dto.Documenti = new DocumentoDTO[item.Documenti.Count];
dto.Documenti[indexDocumenti] = docDto;
indexDocumenti++;
}
return dto;
}
return new AssicurazioneContrattoDTO();
}
catch (Exception ex)
{
_log.Error("Errore nel caricamento di un singolo DTO di un Contratto Assicurativo: " + Utility.GetMethodDescription() + " - id:" + item.ID, ex);
throw;
}
}
public int? ManageDomainEntityAssicurazione(AssicurazioneContrattoDTO assicurazioneContrattoDto)
{
try
{
var contratto = manageAssicurazioneContratto(assicurazioneContrattoDto);
if (contratto != null)
return contratto.ID;
return null;
}
catch (Exception ex)
{
_log.Error("Errore nel caricamento dei contratti assicurativi: " + Utility.GetMethodDescription() + " - id:" + assicurazioneContrattoDto.ID, ex);
throw;
}
}
private void btnPagamentoPremioClick(object sender, EventArgs e)
{
var formPagamento = new PagamentoPremio(_contratto.ImportoPremio);
if (formPagamento.ShowDialog(this) == DialogResult.OK)
{
var contratto = _premioService.Pagamento(_contratto, formPagamento.DataPagamento, formPagamento.Importo);
if (contratto != null)
{
_contratto = contratto;
assicurazioneContrattoDtoBindingSource.DataSource = _contratto;
BusinessClass = new BaseDTOOfint[] { _contratto };
listaPremiAssicurativiUC1.LoadData(_contratto);
}
}
formPagamento.Dispose();
}
protected override bool Save()
{
base.Save();
if (_contratto.Stato != "")
{
_contratto.IdFornitore = fornitore.SelectedFornitore.ID;
var contrattoSave = _contrattoService.Save(_contratto);
if (contrattoSave.ID == 0)
{
CommonMessages.DisplayWarning("Si è verificato un errore: un altro utente ha effettuato un aggiornamento. Uscire e riprovare ");
Dispose();
}
else
{
_contratto = contrattoSave;
assicurazioneContrattoDtoBindingSource.DataSource = _contratto;
BusinessClass = new BaseDTOOfint[] { _contratto };
if ((_listPlugin == null) && (_contratto.ID != 0) && SaveBehavoir != SaveBehavoir.Exit && !Modal)
loadPlugins();
base.SetDirty(false);
btnPagamentoPremio.Enabled = true;
}
}
return true;
}
public void Delete(AssicurazioneContrattoDTO contratto)
{
GetServiceClient().DeleteAssicurazioneContratto(contratto.ID, GetUserInfo());
CloseService();
}
private AssicurazioneContratto manageAssicurazioneContratto(AssicurazioneContrattoDTO assicurazioneContrattoDto)
{
AssicurazioneContratto assc = null;
bool result;
// Controllo sullo stato U, I
switch (assicurazioneContrattoDto.Stato.ToUpper())
{
case "U":
result = updateAssicurazioneContratto(assicurazioneContrattoDto, out assc);
if (!result)
{
//Il dato sul database è più recente di quello utilizzato
//assc.ID = 0;
assc = null;
}
break;
case "I":
result = insertAssicurazioneContratto(assicurazioneContrattoDto, out assc);
if (!result)
throw new Exception("Impossibile scrivere sul database");
break;
}
return assc;
}
public int? SetAssicurazioneContratto(AssicurazioneContrattoDTO assicurazioneContratto, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var repo = new ContrattoRepository(userinfo, windsorRep);
var item = repo.ManageDomainEntityAssicurazione(assicurazioneContratto);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore il salvataggio dell'assicurazione contratto - {0} - id:{1} - condominio:{2} - azienda:{3}", ex, Utility.GetMethodDescription(), assicurazioneContratto.ID, assicurazioneContratto.IdCondominio, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}