public List<RataSoggettoDTO> GetVersatoByEsercizio(EsercizioDTO esercizio, StabileDTO stabile, DateTime? dataLimite, bool soloDaSollecitare)
{
int? idStabile = null;
if (stabile != null)
idStabile = stabile.ID;
var result = GetServiceClient().GetVersatoByEsercizio(esercizio.ID, idStabile, dataLimite, soloDaSollecitare, GetUserInfo());
CloseService();
return result;
}
public override List<MillesimoDTO> GetMillesimiByConti(IList<int> idConti, StabileDTO stabile, GruppoStabileDTO scala)
{
int? idStabile = null;
if (stabile != null)
idStabile = stabile.ID;
int? idScala = null;
if (scala != null)
idScala = scala.ID;
var result = GetServiceClient().GetMillesimiByFilter(new MillesimiFilter { IdConti = new List<int>(idConti), CodiceStabile = idStabile, CodiceScala = idScala }, GetUserInfo());
CloseService();
return result;
}
public StabileDTO[] GetAllByAzienda(int idAzienda)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var lista = daoFactory.GetPalazzinaDao().GetByAzienda(idAzienda);
var stabili = new StabileDTO[lista.Count];
int index = 0;
foreach (Palazzina stabile in lista)
{
stabili[index] = setDto(stabile);
index++;
}
return stabili;
}
catch (Exception ex)
{
_log.Error("Errore nel caricamento degli stabili: " + Library.Utility.GetMethodDescription(), ex);
throw;
}
}
public DataTable GetLetturePivotByEsercizio(EsercizioDTO esercizio, ContatoreDTO contatore, LottoDTO lotto, StabileDTO stabile, GruppoStabileDTO scala)
{
int? idLotto = null;
if (lotto != null)
idLotto = lotto.ID;
int? idStabile = null;
if (stabile != null)
idStabile = stabile.ID;
int? idScala = null;
if (scala != null)
idScala = scala.ID;
var letture = GetServiceClient().GetLettureContatoriByEsercizio(esercizio.ID, esercizio.IdCondominio, contatore.ID, idLotto, idStabile, idScala, GetUserInfo());
var tb = new DataTable("LettureContatori");
tb.Columns.Add("IdUnitaImmobiliare", typeof(int));
tb.Columns.Add("InternoUnitaImmobiliare", typeof(string));
tb.Columns.Add("DescrizioneUnitaImmobiliare", typeof(string));
tb.Columns.Add("OrdineUnitaImmobiliare", typeof(int));
tb.Columns.Add("TipoUnitaImmobiliare", typeof(string));
tb.Columns.Add("Lotto", typeof(string));
tb.Columns.Add("Stabile", typeof(string));
tb.Columns.Add("Scala", typeof(string));
tb.PrimaryKey = new[] { tb.Columns["IdUnitaImmobiliare"] };
// ----------------------------------------------
// Aggiungo una colonna per ogni Data
// ----------------------------------------------
var dateColumn = new List<DataColumn>();
if (letture.Count > 0)
{
var idExampleUnita = letture[0].IdUnitaImmobiliare;
var listaLettureExample = from item in letture
where item != null && item.IdUnitaImmobiliare == idExampleUnita
orderby item.Data
select item;
dateColumn = new List<DataColumn>(listaLettureExample.Count());
dateColumn = listaLettureExample.Aggregate(dateColumn, (current, letturaExample) => addColumnByData(letturaExample.Data, tb, current));
}
// ----------------------------------------------
// Riempio la tabella
// ----------------------------------------------
foreach (var lettura in letture.OrderBy(item => item.OrdineUnitaImmobiliare))
{
var row = tb.Rows.Find(lettura.IdUnitaImmobiliare);
if (row == null)
{
row = tb.NewRow();
row["IdUnitaImmobiliare"] = lettura.IdUnitaImmobiliare;
row["InternoUnitaImmobiliare"] = lettura.InternoUnitaImmobiliare;
row["DescrizioneUnitaImmobiliare"] = lettura.DescrizioneUnitaImmobiliare;
row["OrdineUnitaImmobiliare"] = lettura.OrdineUnitaImmobiliare;
row["TipoUnitaImmobiliare"] = lettura.TipoUnitaImmobiliare;
row["Lotto"] = lettura.Lotto;
row["Stabile"] = lettura.Stabile;
row["Scala"] = lettura.Scala;
tb.Rows.Add(row);
}
if (!tb.Columns.Contains("Data_" + lettura.Data.ToShortDateString()))
dateColumn = addColumnByData(lettura.Data, tb, dateColumn);
if (lettura.Valore != null)
row["Data_" + lettura.Data.ToShortDateString()] = lettura.Valore;
else
row["Data_" + lettura.Data.ToShortDateString()] = DBNull.Value;
}
CloseService();
return tb;
}
public List<ConvocazioneAssembleaDTO> GetConvocatiPerAppello(StabileDTO stabile, GruppoStabileDTO scala)
{
return _assembleaService.GetConvocatiPerAppello(_assemblea, stabile, scala, _convocazione);
}
public List<ConvocazioneAssembleaDTO> GetConvocatiPerAppello(StabileDTO stabile, GruppoStabileDTO scala)
{
//il filtro in locale non riesce ad operare con gli id...spero vada bene anche con le descrizioni
return _appello.Where(item => ((stabile == null || item.Stabile == stabile.Descrizione) && (scala == null || item.GruppoStabile == scala.Descrizione))).ToList();
}
public List<ConvocazioneAssembleaDTO> GetConvocatiPerAppello(AssembleaDTO assemblea, StabileDTO stabile, GruppoStabileDTO scala, int convocazione)
{
int? idStabile = null;
if (stabile != null)
idStabile = stabile.ID;
int? idScala = null;
if (scala != null)
idScala = scala.ID;
List<ConvocazioneAssembleaDTO> result = base.GetServiceClient().GetConvocatiPerAppello(assemblea.ID, idStabile, idScala, convocazione, GetUserInfo());
base.CloseService();
return result;
}
public List<MillesimoDTO> GetRiepilogoMillesimiByEsercizio(IList<int> contiSelezionati, IList<int> unitaSelezionate, StabileDTO stabile, GruppoStabileDTO scala, EsercizioDTO esercizio)
{
var millesimi = new List<MillesimoDTO>();
var service = new PianoContiWCFService(_fornitoreService, _soggettoService);
var millesimiContiSelezionati = service.GetMillesimiByConti(contiSelezionati, stabile, scala);
foreach (var conto in GetDaMillesimareByCondominio(esercizio))
{
var conto1 = conto;
var millesimiConto = from item in millesimiContiSelezionati
where item.IdContoRiferimento == conto1.ID
select item;
millesimi.AddRange(millesimiConto);
}
return new List<MillesimoDTO>
(
(from mill in millesimi
where contiSelezionati.Contains(mill.IdContoRiferimento) &&
unitaSelezionate.Contains(mill.IdUnitaRiferimento)
select mill).ToList()
);
}
public virtual List<MillesimoDTO> GetMillesimiByConti(IList<int> idConti, StabileDTO stabile, GruppoStabileDTO scala)
{
throw new NotImplementedException("Implementare il metodo per il recupero del piano dei conti per esercizio");
}
public string IsAllowDeleteStabile(StabileDTO stabile)
{
var result = string.Empty;
if (stabile.ID != 0)
result = GetServiceClient().IsAllowDeleteStabile(stabile.ID, GetUserInfo());
CloseService();
return result;
}
public StabileDTO[] GetPalazzinaByCondID(int idCondominio)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var lista = daoFactory.GetCondominioDao().GetById(idCondominio, false).Palazzine;
var palazzine = new StabileDTO[lista.Count];
var rep = new StabileRepository(_info, _windsorRepository);
var index = 0;
foreach (var item in lista)
{
palazzine[index] = rep.GetByDomainEntity(item);
index++;
}
return palazzine;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento degli Stabili - {0} - condominio:{1}", ex, Utility.GetMethodDescription(), idCondominio);
throw;
}
}
public List<RiepilogoRataSoggettoDTO> GetRiepilogoVersamentiByEsercizioCondominio(CondominioDTO condominio, EsercizioDTO esercizio, StabileDTO stabile, GruppoStabileDTO scala, ReferenteDTO referente, DateTime? dataInizioRate, DateTime? dataFineRate, DateTime? dataVersamenti, bool groupBySoggetto, bool groupByPersona, bool groupByCondominio, bool grouByEsercizio, bool soloRitardi, decimal importoMinimo, bool sollecitaProprietarioConduzione)
{
int? idStabile = null;
if (stabile != null)
idStabile = stabile.ID;
int? idScala = null;
if (scala != null)
idScala = scala.ID;
int? idEsercizio = null;
if (esercizio != null)
idEsercizio = esercizio.ID;
int? idCondominio = null;
if (condominio != null)
idCondominio = condominio.ID;
int? idReferente = null;
if (referente != null)
idReferente = referente.ID;
var result = GetServiceClient().GetRiepilogoVersamentiByEsercizioCondominio(idCondominio, idEsercizio, idStabile, idScala, idReferente, dataInizioRate, dataFineRate, dataVersamenti, groupBySoggetto, groupByPersona, groupByCondominio, grouByEsercizio, soloRitardi, importoMinimo, sollecitaProprietarioConduzione, GetUserInfo());
CloseService();
return result;
}
private void sceltaCondominioCombo1SelectItem(object sender, DataSourceEventArgs<CondominioDTO> e)
{
Clear();
riepilogoRataSoggettoDTOBindingSource.Clear();
_condominio = e.BusinessEntity;
_esercizio = null;
esercizi.Value = null;
if (_condominio != null)
{
loadEsercizi();
esercizi.Value = null;
if (eserciziDTOBindingSource.Count == 1)
esercizi.SelectedIndex = 0;
}
else
esercizi.Clear();
_stabile = null;
if (_condominio != null)
{
stabileDTOBindingSource.DataSource = getStrutturaCondominioService().GetStabiliByCondominio(_condominio);
stabili.Value = null;
if (stabileDTOBindingSource.Count == 1)
stabili.SelectedIndex = 0;
}
else
stabili.Clear();
}
public DataTable AddDataLettura(ContatoreDTO contatore, CondominioDTO condominio, DataTable tb, DateTime data, LottoDTO lotto, StabileDTO stabile, GruppoStabileDTO scala)
{
var dateColumn = new List<DataColumn>();
int? idLotto = null;
if(lotto != null)
idLotto = lotto.ID;
int? idStabile = null;
if(stabile != null)
idStabile = stabile.ID;
int? idScala = null;
if(scala != null)
idScala = scala.ID;
// Se non sono presenti righe devo caricare tutte le righe per le unità immobiliari presenti
if (tb.Rows.Count == 0)
{
IList<LetturaContatoreDTO> lettureNew = GetServiceClient().GetNewLettura(contatore.ID, data, condominio.ID, idLotto, idStabile, idScala, GetUserInfo());
foreach (var lettura in lettureNew)
{
var row = tb.NewRow();
row["IdUnitaImmobiliare"] = lettura.IdUnitaImmobiliare;
row["InternoUnitaImmobiliare"] = lettura.InternoUnitaImmobiliare;
row["DescrizioneUnitaImmobiliare"] = lettura.DescrizioneUnitaImmobiliare;
row["OrdineUnitaImmobiliare"] = lettura.OrdineUnitaImmobiliare;
row["TipoUnitaImmobiliare"] = lettura.TipoUnitaImmobiliare;
row["Lotto"] = lettura.Lotto;
row["Stabile"] = lettura.Stabile;
row["Scala"] = lettura.Scala;
// Data
dateColumn = addColumnByData(data, tb, dateColumn);
if(lettura.Valore != null)
row["Data_" + data.ToShortDateString()] = lettura.Valore;
else
row["Data_" + data.ToShortDateString()] = DBNull.Value;
tb.Rows.Add(row);
}
}
else
{
dateColumn.AddRange(tb.Columns.Cast<DataColumn>().Where(column => column.ColumnName.StartsWith("Data_")));
addColumnByData(data, tb, dateColumn);
foreach (DataRow row in tb.Rows)
row["Data_" + data.ToShortDateString()] = DBNull.Value;
}
CloseService();
return tb;
}
private void stabiliValueChanged(object sender, EventArgs e)
{
if (stabili.SelectedItem != null)
_stabile = (StabileDTO)stabili.SelectedItem.ListObject;
}
public StabileDTO GetNewStabile(CondominioDTO condominio)
{
var stabile = new StabileDTO
{
GruppiStabile = new List<GruppoStabileDTO>(),
IdCondominio = condominio.ID,
MappaleCatastale = condominio.MappaleCatastale
};
return stabile;
}
public ResultRiepilogoRipartoDTO GetRiepilogoRiparto(int idEsercizio, StabileDTO stabile, GruppoStabileDTO scala, int? idRendiconto, TipoAccorpamentoRateEnum tipo)
{
var retryCount = 5;
var success = false;
int? idStabile = null;
if (stabile != null)
idStabile = stabile.ID;
int? idScala = null;
if (scala != null)
idScala = scala.ID;
ResultRiepilogoRipartoDTO result = new ResultRiepilogoRipartoDTO();
while (retryCount >= 0 && !success)
{
try
{
var info = GetUserInfo();
info.Tentativo = 6 - retryCount;
result = GetServiceClient().GetRiepilogoRiparto(idEsercizio, idStabile, idScala, idRendiconto, tipo, GetUserInfo());
CloseService();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura del riepilogo del riparto per piano rateale - TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3}", ex, (6 - retryCount), Utility.GetMethodDescription(), idEsercizio, Login.Instance.CurrentLogin().Azienda);
retryCount--;
_log.InfoFormat("Esecuzione della funzione - INIZIO TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3}", (6 - retryCount), Utility.GetMethodDescription(), idEsercizio, Login.Instance.CurrentLogin().Azienda);
}
}
return result;
}
public bool DeleteStabile(StabileDTO stabile)
{
var result = GetServiceClient().DeleteStabile(stabile.ID, GetUserInfo());
CloseService();
return result;
}
public int? ManageDomainEntity(StabileDTO dto)
{
try
{
var stabile = manageStabile(dto);
if (stabile != null)
return stabile.ID;
return null;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella gestione degli stabili - {0} - stabile:{1}", ex, Library.Utility.GetMethodDescription(), dto.ID);
throw;
}
}
public DataView GetRiepilogoMillesimiPivotByEsercizio(EsercizioDTO esercizio, StabileDTO stabile, GruppoStabileDTO gruppo)
{
return convertMillesimiToPivot(GetDaMillesimareByCondominio(esercizio), stabile, gruppo);
}
private StabileDTO setDto(Palazzina item)
{
var dto = new StabileDTO
{
Descrizione = item.Descrizione,
Ordine = item.Ordine,
MappaleCatastale = item.MappaleCatastale,
DescrizioneCondominio = item.CondominioRiferimento.DisplayName,
DisplayName = item.DisplayName,
ID = item.ID,
IdCondominio = item.CondominioRiferimento.ID,
Version = item.Version
};
if (item.Indirizzo != null)
{
dto.Cap = item.Indirizzo.Cap;
dto.Civico = item.Indirizzo.Civico;
dto.Indirizzo = item.Indirizzo.Indirizzo;
}
int indexGruppi = 0;
foreach (var gruppo in item.GruppiStabile)
{
var gruppoDto = _gruppoRep.GetByDomainEntity(gruppo);
if (dto.GruppiStabile.Length == 0)
dto.GruppiStabile = new GruppoStabileDTO[item.GruppiStabile.Count];
dto.GruppiStabile[indexGruppi] = gruppoDto;
indexGruppi++;
}
// Lotto
if (item.LottoRiferimento != null)
{
dto.IdLotto = item.LottoRiferimento.ID;
dto.DescrizioneLotto = item.LottoRiferimento.Descrizione;
}
return dto;
}
private DataView convertMillesimiToPivot(List<ContoDTO> conti, StabileDTO stabile, GruppoStabileDTO gruppo)
{
var tb = new DataTable("MillesimiPivot");
tb.Columns.Add("IdUnitaImmobiliare", typeof(int));
tb.Columns.Add("OrdineUnitaImmobiliare", typeof(int));
tb.Columns.Add("DescrizioneUnitaImmobiliare", typeof(string));
tb.Columns.Add("TipoUnitaImmobiliare", typeof(string));
tb.Columns.Add("InternoUnitaImmobiliare", typeof(string));
tb.Columns.Add("Stabile", typeof(string));
tb.Columns.Add("Scala", typeof(string));
tb.PrimaryKey = new[] { tb.Columns["IdUnitaImmobiliare"] };
var service = new PianoContiWCFService(_fornitoreService, _soggettoService);
var idConti = new List<int>(conti.Count);
idConti.AddRange(conti.Select(conto => conto.ID));
var millesimi = service.GetMillesimiByConti(idConti, stabile, gruppo);
// ----------------------------------------------
// Aggiungo una colonna per ogni Conto
// ----------------------------------------------
var contoColumns = new List<DataColumn>(conti.Count);
foreach (var conto in conti.OrderBy(item => item.Ordine))
contoColumns = addColumnByConto(conto.ID, conto.Descrizione, tb, contoColumns);
// ----------------------------------------------
// Riempio la tabella
// ----------------------------------------------
foreach (var conto in conti)
{
var conto1 = conto;
var millesimiSelezionati = from millesimo in millesimi
where millesimo.IdContoRiferimento == conto1.ID &&
(gruppo == null || millesimo.IdGruppoRiferimento == gruppo.ID) &&
(stabile == null || millesimo.IdStabileRiferimento == stabile.ID)
select millesimo;
foreach (var millesimo in millesimiSelezionati)
{
var row = tb.Rows.Find(millesimo.IdUnitaRiferimento);
if (row == null)
{
row = tb.NewRow();
row["IdUnitaImmobiliare"] = millesimo.IdUnitaRiferimento;
row["OrdineUnitaImmobiliare"] = millesimo.Ordine;
row["DescrizioneUnitaImmobiliare"] = millesimo.NominativoUnitaRiferimento;
row["TipoUnitaImmobiliare"] = millesimo.TipoUnitaRiferimento;
row["InternoUnitaImmobiliare"] = millesimo.InternoUnitaRiferimento;
row["Stabile"] = millesimo.DescrizioneStabileRiferimento;
row["Scala"] = millesimo.DescrizioneGruppoRiferimento;
tb.Rows.Add(row);
}
var valore = millesimo.Valore ?? (object) DBNull.Value;
row["Conto_" + conto.ID + "_" + conto.Descrizione] = valore;
row["Ripartizione_" + conto.ID + "_" + conto.Descrizione] = millesimo.RipartizionePersonalizzata;
}
}
return new DataView(tb, string.Empty, "OrdineUnitaImmobiliare", DataViewRowState.Added);
}
private bool update(StabileDTO dto, out Palazzina item)
{
bool result;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
item = daoFactory.GetPalazzinaDao().GetById(dto.ID, false);
// Condizione necessaria per il controllo del fatto che sul DB ho una versione uguale o più vecchia
// Per ora non sono eseguiti controlli di concorrenza
if (dto.Version == item.Version || true)
{
item.CondominioRiferimento = daoFactory.GetCondominioDao().GetById(dto.IdCondominio, false);
item.Descrizione = dto.Descrizione;
item.Ordine = dto.Ordine;
item.MappaleCatastale = dto.MappaleCatastale;
#region Indirizzo
item.Indirizzo = new Address {Indirizzo = dto.Indirizzo, Civico = dto.Civico, Cap = dto.Cap};
if (item.CondominioRiferimento.Indirizzo != null)
{
if (item.Indirizzo.Comune != null)
item.Indirizzo.Comune = item.CondominioRiferimento.Indirizzo.Comune;
if (string.IsNullOrEmpty(item.Indirizzo.Indirizzo))
item.Indirizzo.Indirizzo = item.CondominioRiferimento.Indirizzo.Indirizzo;
if (string.IsNullOrEmpty(item.Indirizzo.Cap))
item.Indirizzo.Cap = item.CondominioRiferimento.Indirizzo.Cap;
if (string.IsNullOrEmpty(item.Indirizzo.Civico))
item.Indirizzo.Civico = item.CondominioRiferimento.Indirizzo.Civico;
if (string.IsNullOrEmpty(item.Indirizzo.Localita))
item.Indirizzo.Localita = item.CondominioRiferimento.Indirizzo.Localita;
if (item.Indirizzo.Nazione == null)
item.Indirizzo.Nazione = item.CondominioRiferimento.Indirizzo.Nazione;
}
#endregion Indirizzo
// -------------------------------------
// Lotto Riferimento
// -------------------------------------
item.LottoRiferimento = null;
if (dto.IdLotto > 0)
item.LottoRiferimento = daoFactory.GetLottoDao().Find(dto.IdLotto, false);
// ------------------------------------------------------
// Gruppi Stabile
// ------------------------------------------------------
item.GruppiStabile.Clear();
foreach (var t in dto.GruppiStabile)
{
t.IdStabile = item.ID;
var id = t.ID;
if ((t.Stato == "U") || (t.Stato == "I"))
{
var manageDomainEntity = getGruppoStabileRepository().ManageDomainEntity(t);
if (manageDomainEntity != null)
id = (int)manageDomainEntity;
}
var gruppo = daoFactory.GetGruppoStabileDao().Find(id, false);
if (gruppo != null)
{
item.GruppiStabile.Add(gruppo);
gruppo.PalazzinaRiferimento = item;
}
}
daoFactory.GetPalazzinaDao().Update(item);
result = true;
}
else
{
// Eccezione: Sul db c'è qualche cosa di più nuovo.
_log.ErrorFormat("Errore nel salvataggio dello stabile - id:{0} - il dato sul db è più recente di quello che si vuole salvare", dto.ID);
result = false;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio dello stabile - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), dto.ID, ex);
throw;
}
return result;
}
public List<ConvocazioneAssembleaDTO> GetVotanti(AssembleaDTO assemblea, OrdineGiornoAssembleaDTO ordineGiorno, StabileDTO stabile, GruppoStabileDTO scala)
{
List<int> votanti = new List<int>();
if (scala != null)
votanti.Add(scala.ID);
else if (stabile != null)
{
foreach (GruppoStabileDTO gruppo in stabile.GruppiStabile)
votanti.Add(gruppo.ID);
}
else
votanti = null;
List<ConvocazioneAssembleaDTO> result = base.GetServiceClient().GetVotantiAssemblea(assemblea.ID, ordineGiorno.ID, votanti, GetUserInfo());
base.CloseService();
return result;
}
private bool insert(StabileDTO dto, out Palazzina item)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
item = null;
try
{
var condominio = daoFactory.GetCondominioDao().Find(dto.IdCondominio, false);
if (condominio != null)
{
item = dto.GruppiStabile.Length > 0 ? new Palazzina(condominio, dto.Descrizione, false) : new Palazzina(condominio, dto.Descrizione, true);
item.Ordine = dto.Ordine;
item.MappaleCatastale = dto.MappaleCatastale;
#region Indirizzo
item.Indirizzo = new Address { Indirizzo = dto.Indirizzo, Civico = dto.Civico, Cap = dto.Cap };
if (item.CondominioRiferimento.Indirizzo != null)
{
item.Indirizzo.Comune = item.CondominioRiferimento.Indirizzo.Comune;
item.Indirizzo.Localita = item.CondominioRiferimento.Indirizzo.Localita;
item.Indirizzo.Nazione = item.CondominioRiferimento.Indirizzo.Nazione;
if (string.IsNullOrEmpty(item.Indirizzo.Cap))
item.Indirizzo.Cap = item.CondominioRiferimento.Indirizzo.Cap;
if (string.IsNullOrEmpty(item.Indirizzo.Civico))
item.Indirizzo.Civico = item.CondominioRiferimento.Indirizzo.Civico;
if (string.IsNullOrEmpty(item.Indirizzo.Indirizzo))
item.Indirizzo.Indirizzo = item.CondominioRiferimento.Indirizzo.Indirizzo;
}
#endregion Indirizzo
daoFactory.GetPalazzinaDao().SaveOrUpdate(item);
// -------------------------------------
// Lotto Riferimento
// -------------------------------------
if (dto.IdLotto > 0)
item.LottoRiferimento = daoFactory.GetLottoDao().GetById(dto.IdLotto, false);
// ------------------------------------------------------
// Gruppi Stabile
// ------------------------------------------------------
item.GruppiStabile.Clear();
foreach (GruppoStabileDTO t in dto.GruppiStabile)
{
t.IdStabile = item.ID;
int id = t.ID;
if ((t.Stato == "U") || (t.Stato == "I"))
{
var manageDomainEntity = getGruppoStabileRepository().ManageDomainEntity(t);
if (manageDomainEntity != null)
id = (int)manageDomainEntity;
}
var gruppo = daoFactory.GetGruppoStabileDao().GetById(id, false);
item.GruppiStabile.Add(gruppo);
gruppo.PalazzinaRiferimento = item;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio dello stabile - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), dto.ID);
throw;
}
return true;
}
public List<ConvocazioneAssembleaDTO> GetVotantiPerVotazione(OrdineGiornoAssembleaDTO ordineGiorno, StabileDTO stabile, GruppoStabileDTO scala)
{
//capire come cavolo implemetare il filtro per stabile e scala...
var oVotanti= _votanti[ordineGiorno.ID];
return oVotanti.Where(item => ((stabile == null || item.Stabile == stabile.Descrizione) && (scala == null || item.GruppoStabile == scala.Descrizione))).ToList();
}
private Palazzina manageStabile(StabileDTO stabileDto)
{
Palazzina palazzina = null;
bool result;
// Controllo sullo stato U, D, I
switch (stabileDto.Stato.ToUpper())
{
case "U":
result = update(stabileDto, out palazzina);
if (!result)
throw new Exception("Il dato sul database è più recente di quello utilizzato");
break;
case "I":
result = insert(stabileDto, out palazzina);
if (!result)
throw new Exception("Impossibile scrivere sul database");
break;
}
return palazzina;
}
public List<ConvocazioneAssembleaDTO> GetVotantiPerVotazione(OrdineGiornoAssembleaDTO ordineGiorno, StabileDTO stabile, GruppoStabileDTO scala)
{
return _assembleaService.GetVotantiPerVotazione(_assemblea, ordineGiorno, stabile, scala, _convocazione);
}
public int? SetStabile(StabileDTO stabile, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new StabileRepository(userinfo, windsorRep);
var item = rep.ManageDomainEntity(stabile);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore il salvataggio dello stabile - {0} - id:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), stabile.ID, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
