public static Rendiconto CreateRendiconto(DTORendiconto dto)
{
Rendiconto r = CreateRendiconto(!dto.IsRegionale, dto.Provincia, dto.Anno, dto.Regione);
r.Proprietario = dto.Proprietario;
//questa istruzione è neecessaria per calcolare i totali sui conti e
//non sulle scritture
r.Bilancio = r.Preventivo;
BilancioNew b = r.Bilancio;
//Bilancio p = r.Preventivo;
foreach (DTORendicontoItem item in dto.Items)
{
AbstractBilancio c = b.FindNodeById(item.IdNodo) as ContoPreventivo;
if (c != null)
{
c.Importo = item.ImportoBilancio;
}
//AbstractBilancio c1 = p.FindNodeById(item.IdNodo) as ContoPreventivo;
//if (c1 != null)
// c1.Importo = item.ImportoPreventivo;
}
return(r);
}
public IList CreateListaConti(string nodeId)
{
IList result = new ArrayList();
//definisco il nodo da dove eseguire la ricerca dei conti
AbstractBilancio mainNode = null;
//se il node id è nullo allora il main node sarà se stesso
if (string.IsNullOrEmpty(nodeId))
{
mainNode = this;
}
else
{
mainNode = this.FindNodeById(nodeId);
}
if (mainNode == null)
{
return(result);
}
//se il nodo è una foglia lo aggiungo alla lista e ritorno
if ((mainNode.IsLeaf))
{
result.Add(mainNode);
return(result);
}
DoCreateListConti(result, mainNode);
return(result);
}
protected void FillDTORendicontoItemList(IList items, Rendiconto rendiconto, int livello)
{
//inserisco il dato relativo al nodo corrente
DTORendicontoItem i = new DTORendicontoItem();
if (string.IsNullOrEmpty(_id))
{
i.IdNodo = "Bilancio";
}
else
{
i.IdNodo = _id;
}
if (string.IsNullOrEmpty(_parentId))
{
if (!string.IsNullOrEmpty(_id))
{
i.IdNodoPadre = "Bilancio";
}
else
{
i.IdNodoPadre = "";
}
}
else
{
i.IdNodoPadre = _parentId;
}
i.DescrizioneNodo = _description;
i.ImportoBilancio = GetTotal;
//i.SaldoIninziale = _saldoIniziale;
i.Livello = livello;
i.IsLeaf = this.IsLeaf;
//se sono nella root (nodo bialncio senza id)
if (_id == "")
{
i.ImportoPreventivo = 0;
}
else
{
AbstractBilancio b = rendiconto.Preventivo.FindNodeById(_id);
if (b != null)
{
i.ImportoPreventivo = b.GetTotal;
}
}
//aggiungo alla lista
items.Add(i);
//inserisco il dato relativo ai nodi figli se
//non sono su una foglia
if (!IsLeaf)
{
int lev = livello + 1;
foreach (AbstractBilancio item in _sublist)
{
item.FillDTORendicontoItemList(items, rendiconto, lev);
}
}
}
/// <summary>
/// Matodo utilizzato per rimuovoere una scrittur, un conto , una classificazione
/// </summary>
/// <param name="part"></param>
public virtual void Remove(AbstractBilancio part)
{
foreach (AbstractBilancio item in _sublist)
{
if (item.Id.Equals(part.Id))
{
_sublist.Remove(item);
return;
}
}
}
public virtual void Add(AbstractBilancio part)
{
AbstractBilancio p = part as Scrittura;
if (p != null)
{
throw new InvalidOperationException("Impossibile aggiungere una scrittura ad una classificazione generica");
}
_sublist.Add(part);
}
private AbstractBilancio GetStructure(NodeUpdate item)
{
AbstractBilancio structure = null;
if (item.UpdateType == "Bilancio")
{
structure = _bilancio;
}
else if (item.UpdateType == "Preventivo")
{
structure = _preventivo;
}
return(structure);
}
private void DoCreateListConti(IList result, AbstractBilancio mainNode)
{
foreach (AbstractBilancio item in mainNode.SubList)
{
if (item.IsLeaf)
{
result.Add(item);
}
else
{
DoCreateListConti(result, item);
}
}
}
protected AbstractBilancio FindSubNodeByBescriptionPath(ArrayList arr, AbstractBilancio current)
{
//se si tratta di una foglia ritorno un valore null
//in quanto non può verificare i sottonodi
if (IsLeaf)
{
return(null);
}
// se nella ricorsione non trovo elementi da ricercare
//c'è un errore nell'algoritmo
if (arr.Count == 0)
{
throw new Exception("Errore nella ricerca del nodo. Lista elementi da ricercare vuota prima di eseguire il confronto");
}
// prendo il primo elemento
string check = arr[0].ToString();
//ciclo su tutti gli elementi in lista
foreach (AbstractBilancio item in current.SubList)
{
//opero il confronto con la descrizione dell'elemento
if (item.Description.Equals(check))
{
//se la descrizione è la stessa ho trovato il nodo
//relativo al check
//rimuovo l'elemento trovato dalla lista e se la lista è vuota vuol dire che
//ho trovato l'elemento che mi interessa
arr.RemoveAt(0);
if ((arr.Count == 0) || IsLeaf)
{
return(item);
}
return(FindSubNodeByBescriptionPath(arr, item));
}
}
return(null);
}
public void CheckMandatoryContosChangedByVersions()
{
AbstractBilancio banca = _bilancio.FindNodeById(BANCA4);
AbstractBilancio bancaPreventivo = _preventivo.FindNodeById(BANCA4);
if (banca == null && bancaPreventivo == null)
{
//vuol dire che non cè la banca allora creo la lista delle banche per il bilancio e per il preventivo
//crerco il nodo deli depositi bancari
AbstractBilancio depositi = _bilancio.FindNodeById(DEPOSITI_BANCARI_E_POSTALI);
depositi.Add(new Conto("Banca4", "A.D.2.d", "A.D.2"));
depositi.Add(new Conto("Banca5", "A.D.2.e", "A.D.2"));
depositi.Add(new Conto("Banca6", "A.D.2.f", "A.D.2"));
AbstractBilancio depositiPreventivo = _preventivo.FindNodeById(DEPOSITI_BANCARI_E_POSTALI);
depositiPreventivo.Add(new ContoPreventivo("Banca4", "A.D.2.d", "A.D.2"));
depositiPreventivo.Add(new ContoPreventivo("Banca5", "A.D.2.e", "A.D.2"));
depositiPreventivo.Add(new ContoPreventivo("Banca6", "A.D.2.f", "A.D.2"));
}
}
/// <summary>
/// Ricerca un nodo attraverso il proprio id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public AbstractBilancio FindNodeById(string id)
{
if (string.IsNullOrEmpty(id))
{
return(null);
}
if (_id.Equals(id))
{
return(this);
}
foreach (AbstractBilancio item in _sublist)
{
AbstractBilancio b = item.FindNodeById(id);
if (b != null)
{
return(b);
}
}
return(null);
}
private bool UpdateBilancio(NodeUpdate item)
{
AbstractBilancio structure = GetStructure(item);
if (structure == null)//c'è un errore nel file
{
return(false);
}
//il parent non può essere una stringa nulla poichè rappresenterebbe
//la radice dell'albero che può avere solo le voci di spesa, entrate e finanza
if (string.IsNullOrEmpty(item.ParentId))
{
return(false);
}
//se devo aggiungere o modificare un nodo esso deve avere un
//id ed una descrizione non nulli
if (string.IsNullOrEmpty(item.Id))
{
return(false);
}
if (string.IsNullOrEmpty(item.Description))
{
return(false);
}
//a questo punto verifico per prima cosa l'esistenza del parent
//se non esiste c'è un errore nel file.
//anche se teoricamente il processo potrebbe continuare è bene che il file sia sempre corretto
AbstractBilancio parent = structure.FindNodeById(item.ParentId);
if (parent == null)
{
return(false);
}
//a questo punto il parent esiste.
//rimane da verifica che il nodo da aggiornare se esiste esiste sotto il parent
// altrimenti si tratta di una imprecisione nel file di aggiornamento
AbstractBilancio nodeInStructure = structure.FindNodeById(item.Id);
AbstractBilancio nodeInParent = structure.FindNodeById(item.Id);
//se non sono nulli vuol dire che il nodo è al di sotto del parent
//ed è pronto per essere modificato
if (nodeInParent != null && nodeInStructure != null)
{
nodeInParent.Description = item.Description;
return(true);
}
else if (nodeInParent == null && nodeInStructure == null)//il nodo non esiste e va creato
{
AbstractBilancio b = CreateStructureItem(item.ContoType, item.Id, item.Description, item.ParentId);
b.ParentName = parent.Description;
parent.Add(b);
return(true);
}
else // c'è un errore nel file
{
return(false);
}
}
public override void Add(AbstractBilancio part)
{
throw new InvalidOperationException("Tentativo di aggiungere sottoelementi ad un conto preventivo");
}
public void Remove(string idScrittura, AbstractBilancio cp)
{
Scrittura s = FindNodeById(idScrittura) as Scrittura;
if (s == null)
{
return;
}
//commento la riga di codice che verifica la presenza di una
//scrittura autogenerata in un conto finanziario. Tale scrittura puo'
//trovarsi in qualsiasi tipo di conto.
//if (CalculateTipoConto() == TipoConto.Finanza)
if (s.AutoGenerated == true)
{
throw new InvalidOperationException("Impossibile eliminare una scrittura autogenerata. Per eliminarla procedere alla eliminazione della scrittura dal relativo conto!");
}
//se il conto di contropartita risulta nullo vuol dire che devo cercare la scrittura
//di cotropartita nell'albero delle entrate o delle uscite a seconda che il tipoConto
//sia entrate o uscite
//if (contoContropartita != null)
//{
BilancioNew bil = cp as BilancioNew;
if (bil == null)
{
throw new InvalidOperationException("Impossibile convertire la contropartita di una partita di giro in un oggetto Bilancio da cui ricercare i conto di contropartita!!!");
}
Conto contoContropartita = bil.FindNodeById(s.IdContropartita) as Conto;
Scrittura s1 = contoContropartita.FindNodeById(s.Id) as Scrittura;
if (s1 != null)
{
contoContropartita.Remove(s1);
}
//}
//else
//{
// TipoConto c = CalculateTipoConto();
// //se la contropartita è nulla vuol dire che ho passato l'intero bilancio
// Bilancio bil = cp as Bilancio;
// // se è nullo c'è un errore imprevisto
// if (bil == null)
// throw new InvalidOperationException("Impossibile convertire la contropartita di una partita di giro in un oggetto Bilancio da cui ricercare i conto di contropartita!!!");
// //*****************************
// //definisco l'id della classificazione dove ricercare il conto
// string idClassificazione = "";
// if (c == TipoConto.Entrate)
// //dovro' cercare la scrittura di contropartita nelle spese
// idClassificazione = "S";
// else
// //dovro' cercare la scrittura di contropartita nelle entrate
// idClassificazione = "E";
// //rimuovo la scrittura previa ricerca
// Classificazione clas = bil.FindNodeById(idClassificazione) as Classificazione;
// //cerco la scritttura
// Scrittura s1 = clas.FindNodeById(s.Id) as Scrittura;
// if (s1 != null)
// {
// //ne recupero il conto padre
// Conto cc = clas.FindNodeById(s1.ParentId) as Conto;
// //la elimino dal conto
// cc.Remove(s1);
// }
// //*************************************************
//}
_sublist.Remove(s);
}
public override void Add(AbstractBilancio part)
{
throw new InvalidOperationException("Chiamata a metodo non implementato. Utilizzare metodo alternativo!");
}
