public DettaglioUnitaImmobiliareUI(UnitaImmobiliareDTO unita, bool disableEditing) : base(disableEditing)
{
InitializeComponent();
inizializza();
_gruppoStabile = unita.GruppoStabileRiferimento;
_unitaImmobiliare = unita;
}
public DettaglioUnitaImmobiliareUI(int idUnitaImmobiliare)
{
InitializeComponent();
inizializza();
_unitaImmobiliare = _unitaImmobiliareService.GetByID(idUnitaImmobiliare);
_gruppoStabile = _unitaImmobiliare.GruppoStabileRiferimento;
unitaImmobiliareBindingSource.DataSource = _unitaImmobiliare;
BusinessClass = new BaseDTOOfint[] { _unitaImmobiliare };
}
public RiepilogoRateVersateUC(CondominioDTO condominio, EsercizioDTO esercizio, bool isRequiredDataContabile, GruppoStabileDTO scala, bool soloEserciziAperti)
{
_condominio = condominio;
_esercizio = esercizio;
_isRequiredDataContabile = isRequiredDataContabile;
_scala = scala;
_soloEserciziAperti = soloEserciziAperti;
InitializeComponent();
inizializza();
}
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 GruppoStabileDTO[] GetAllByAzienda(int idAzienda)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var lista = daoFactory.GetGruppoStabileDao().GetByAzienda(idAzienda);
var gruppi = new GruppoStabileDTO[lista.Count];
int index = 0;
foreach (var gruppo in lista)
{
gruppi[index] = setDto(gruppo);
index++;
}
return gruppi;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento dei gruppi stabili (scale) - {0}", ex, Library.Utility.GetMethodDescription());
throw;
}
}
private GruppoStabile manageGruppo(GruppoStabileDTO gruppoDto)
{
GruppoStabile gruppo = null;
bool result;
// Controllo sullo stato U, I
switch (gruppoDto.Stato.ToUpper())
{
case "U":
result = update(gruppoDto, out gruppo);
if (!result)
throw new Exception("Il dato sul database è più recente di quello utilizzato");
break;
case "I":
result = insert(gruppoDto, out gruppo);
if (!result)
throw new Exception("Impossibile scrivere sul database");
break;
}
return gruppo;
}
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");
}
private bool update(GruppoStabileDTO dto, out GruppoStabile item)
{
bool result;
item = null;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
item = daoFactory.GetGruppoStabileDao().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.Descrizione = dto.Descrizione;
item.Ordine = dto.Ordine;
#region Indirizzo
item.Indirizzo = new Address {Indirizzo = dto.Indirizzo, Civico = dto.Civico, Cap = dto.Cap};
Address indirizzoPincipale = null;
if (item.PalazzinaRiferimento.Indirizzo != null)
indirizzoPincipale = item.PalazzinaRiferimento.Indirizzo;
else if(item.PalazzinaRiferimento.CondominioRiferimento.Indirizzo != null)
indirizzoPincipale = item.PalazzinaRiferimento.CondominioRiferimento.Indirizzo;
if (indirizzoPincipale != null)
{
if (item.Indirizzo.Comune != null)
item.Indirizzo.Comune = indirizzoPincipale.Comune;
if (string.IsNullOrEmpty(item.Indirizzo.Indirizzo))
item.Indirizzo.Indirizzo = indirizzoPincipale.Indirizzo;
if (string.IsNullOrEmpty(item.Indirizzo.Cap))
item.Indirizzo.Cap = indirizzoPincipale.Cap;
if (string.IsNullOrEmpty(item.Indirizzo.Civico))
item.Indirizzo.Civico = indirizzoPincipale.Civico;
if (string.IsNullOrEmpty(item.Indirizzo.Localita))
item.Indirizzo.Localita = indirizzoPincipale.Localita;
if (item.Indirizzo.Nazione == null)
item.Indirizzo.Nazione = indirizzoPincipale.Nazione;
}
#endregion Indirizzo
// -------------------------------------
// Palazzina Riferimento
// -------------------------------------
if (dto.IdStabile > 0)
item.PalazzinaRiferimento = daoFactory.GetPalazzinaDao().GetById(dto.IdStabile, false);
daoFactory.GetGruppoStabileDao().Update(item);
result = true;
}
else
{
// Eccezione: Sul db c'è qualche cosa di più nuovo.
_log.ErrorFormat("Errore nel salvataggio dei gruppi - 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 dei gruppi - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), dto.ID);
throw;
}
return result;
}
private bool insert(GruppoStabileDTO dto, out GruppoStabile item)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
item = new GruppoStabile(daoFactory.GetPalazzinaDao().GetById(dto.IdStabile, false), dto.Descrizione)
{
Ordine = dto.Ordine,
Indirizzo = new Address {Indirizzo = dto.Indirizzo, Civico = dto.Civico, Cap = dto.Cap}
};
#region Indirizzo
Address indirizzoPincipale = null;
if (item.PalazzinaRiferimento.Indirizzo != null)
indirizzoPincipale = item.PalazzinaRiferimento.Indirizzo;
else if (item.PalazzinaRiferimento.CondominioRiferimento.Indirizzo != null)
indirizzoPincipale = item.PalazzinaRiferimento.CondominioRiferimento.Indirizzo;
if (indirizzoPincipale != null)
{
item.Indirizzo.Comune = indirizzoPincipale.Comune;
item.Indirizzo.Localita = indirizzoPincipale.Localita;
item.Indirizzo.Nazione = indirizzoPincipale.Nazione;
if (string.IsNullOrEmpty(item.Indirizzo.Cap))
item.Indirizzo.Cap = indirizzoPincipale.Cap;
if (string.IsNullOrEmpty(item.Indirizzo.Civico))
item.Indirizzo.Civico = indirizzoPincipale.Civico;
if (string.IsNullOrEmpty(item.Indirizzo.Indirizzo))
item.Indirizzo.Indirizzo = indirizzoPincipale.Indirizzo;
}
#endregion Indirizzo
daoFactory.GetGruppoStabileDao().SaveOrUpdate(item);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'inserimento del gruppo stabile - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), dto.ID);
throw;
}
return true;
}
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;
}
private GruppoStabileDTO setDto(GruppoStabile item)
{
var dto = new GruppoStabileDTO
{
Descrizione = item.Descrizione,
DescrizioneStabile = item.PalazzinaRiferimento.Descrizione,
ID = item.ID,
IdStabile = item.PalazzinaRiferimento.ID,
Ordine = item.Ordine,
Version = item.Version
};
if (item.Indirizzo != null)
{
dto.Cap = item.Indirizzo.Cap;
dto.Civico = item.Indirizzo.Civico;
dto.Indirizzo = item.Indirizzo.Indirizzo;
}
return dto;
}
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(StabileDTO stabile, GruppoStabileDTO scala)
{
return _assembleaService.GetConvocatiPerAppello(_assemblea, stabile, scala, _convocazione);
}
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 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;
}
public bool DeleteGruppoStabile(GruppoStabileDTO stabile)
{
var result = GetServiceClient().DeleteGruppoStabile(stabile.ID, GetUserInfo());
CloseService();
return result;
}
public string IsAllowDeleteGruppoStabile(GruppoStabileDTO gruppo)
{
var result = string.Empty;
if (gruppo.ID != 0)
result = GetServiceClient().IsAllowDeleteGruppoStabile(gruppo.ID, GetUserInfo());
CloseService();
return result;
}
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 RiepilogoRateVersateUC(GruppoStabileDTO scala)
{
_scala = scala;
InitializeComponent();
inizializza();
}
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;
}
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;
}
public DataView GetRiepilogoMillesimiPivotByEsercizio(EsercizioDTO esercizio, StabileDTO stabile, GruppoStabileDTO gruppo)
{
return convertMillesimiToPivot(GetDaMillesimareByCondominio(esercizio), stabile, gruppo);
}
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()
);
}
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);
}
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();
}
public int? ManageDomainEntity(GruppoStabileDTO dto)
{
try
{
return manageGruppo(dto).ID;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella gestione dei gruppi - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), dto.ID);
throw;
}
}
public List<ConvocazioneAssembleaDTO> GetVotantiPerVotazione(OrdineGiornoAssembleaDTO ordineGiorno, StabileDTO stabile, GruppoStabileDTO scala)
{
return _assembleaService.GetVotantiPerVotazione(_assemblea, ordineGiorno, stabile, scala, _convocazione);
}
public int? SetGruppoStabile(GruppoStabileDTO gruppoStabileDto, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var repo = new GruppoStabileRepository(userinfo, windsorRep);
var item = repo.ManageDomainEntity(gruppoStabileDto);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio dei gruppi stabili - {0} - id:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), gruppoStabileDto.ID, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
