Exemple #1
0
        /// <summary>
        /// Metodo utilizzato dal client per inserire una nuova scrittura nel conto
        /// </summary>
        /// <param name="part">Questa è la scrittura che deve essere inserita nel conto già correttamente valorizzata</param>
        /// <param name="contoContropartita">il conto di contropartita è
        /// il conto dove la scrittura gemella deve essere aggiunta per la quadratura di tutto il bliancio</param>
        /// <param name="scritturaPartitaDoppia">il parametro partita doppia serve per indicare  se la scrittura corrente è la
        /// scrittura che sarà scritta nella contropartita: lo stesso metodo è utilizzato per aggiungere la scrittura al conto principale che al conto di contropartita.
        /// Se sto aggiungendo la scrittura al conto principale allora il parametro sarà negativo. Vedi implementazione....</param>
        public virtual void Add(Scrittura part, Conto contoContropartita, bool scritturaPartitaDoppia)
        {
            if (scritturaPartitaDoppia == false)
            {
                if (contoContropartita != null)
                {
                    if (this.Id.Equals(contoContropartita.Id))
                    {
                        throw new Exception("Impossibile scrivere una scrittura in partita doppia sullo stesso conto!");
                    }
                }
            }

            part.ParentId = this.Id;



            if (scritturaPartitaDoppia)
            {
                _sublist.Add(part);
                return;
            }

            AddScritturaPartitaDoppia(contoContropartita, part);
        }
Exemple #2
0
        //private TipoConto CalculateTipoConto()
        //{
        //    TipoConto c;
        //    if (_id.StartsWith("E"))
        //        c = TipoConto.Entrate;
        //    else if (_id.StartsWith("S"))
        //        c = TipoConto.Spese;
        //    else
        //        c = TipoConto.Finanza;
        //    return c;
        //}

        //private void AddScritturaPartitaDoppia(TipoConto c, Conto contoContropartita, Scrittura scrittura)
        //{
        //    //mi serve per impostare il nome del campo contropartita su ogni scrittura
        //    //presente sul conto
        //    string nomeContropartita = contoContropartita.Description;
        //    scrittura.Contropartita = nomeContropartita;

        //    if (c == TipoConto.Finanza && Conto.CalculateTipoConto(contoContropartita.Id) == TipoConto.Entrate)
        //        throw new InvalidOperationException("Operazione Finanza --> Entrate non consentita");
        //    if (c == TipoConto.Finanza && Conto.CalculateTipoConto(contoContropartita.Id) == TipoConto.Spese)
        //        throw new InvalidOperationException("Operazione Finanza --> Spese non consentita");

        //    if (c == TipoConto.Spese && Conto.CalculateTipoConto(contoContropartita.Id) == TipoConto.Spese)
        //        throw new InvalidOperationException("Operazione Spese --> Spese non consentita");
        //    if (c == TipoConto.Entrate && Conto.CalculateTipoConto(contoContropartita.Id) == TipoConto.Entrate)
        //        throw new InvalidOperationException("Operazione Spese --> Spese non consentita");


        //    //se si tratta di una scrittura in partita di giro
        //    //spese --> entrate oppure entrate --> spese
        //    if ((c == TipoConto.Spese && Conto.CalculateTipoConto(contoContropartita.Id) == TipoConto.Entrate) || (c == TipoConto.Entrate && Conto.CalculateTipoConto(contoContropartita.Id) == TipoConto.Spese))
        //    {
        //        //aggiungo l'elemento alla lista
        //        _sublist.Add(scrittura);
        //        //aggiungo l'elemnto alla cassa
        //        Scrittura s = new Scrittura(scrittura, false, _description);
        //        s.ParentName = contoContropartita.Description;
        //        //se invece sto inserendo la scrittura
        //        //di contropartita ne scrivo il conto di contropartita
        //        s.Contropartita = this._description;
        //        contoContropartita.Add(s, contoContropartita, true);
        //    }
        //    else
        //    {


        //        if (c == TipoConto.Entrate)
        //        {
        //            //aggiungo l'elemento alla lista
        //            _sublist.Add(scrittura);
        //            //aggiungo l'elemnto alla cassa
        //            Scrittura s = new Scrittura(scrittura, false, _description);
        //            s.ParentName = contoContropartita.Description;
        //            //se invece sto inserendo la scrittura
        //            //di contropartita ne scrivo il conto di contropartita
        //            s.Contropartita = this._description;
        //            contoContropartita.Add(s, contoContropartita, true);
        //        }
        //        else
        //        {
        //            //aggiungo l'elemento alla lista
        //            _sublist.Add(scrittura);
        //            Scrittura s = new Scrittura(scrittura, true, _description);
        //            s.ParentName = contoContropartita.Description;
        //            //se invece sto inserendo la scrittura
        //            //di contropartita ne scrivo il conto di contropartita
        //            s.Contropartita = this._description;
        //            //aggiungo l'elemnto alla cassa cambiandogli il segno
        //            contoContropartita.Add(s, contoContropartita, true);
        //        }

        //    }

        //}

        //public static TipoConto CalculateTipoConto(string id)
        //{
        //    BilancioFenealgest.DomainLayer.Conto.TipoConto c;
        //    if (id.StartsWith("E"))
        //        c = BilancioFenealgest.DomainLayer.Conto.TipoConto.Entrate;
        //    else if (id.StartsWith("S"))
        //        c = BilancioFenealgest.DomainLayer.Conto.TipoConto.Spese;
        //    else
        //        c = BilancioFenealgest.DomainLayer.Conto.TipoConto.Finanza;
        //    return c;
        //}



        //public enum TipoConto
        //{
        //    Entrate,
        //    Spese,
        //    Finanza
        //}



        //metodo per indicare se una operazione necessiti che la scrittura da aggiungere alla contropartita sarà scritta con importo negato
        private static bool NegateImportoOperazione(Conto conto, Conto contropartita)
        {
            DirezioneOperazione op = CalcolaDirezioneOperazione(conto, contropartita);

            if (op == DirezioneOperazione.Orizzontale)
            {
                return(false);
            }


            return(true);
        }
Exemple #3
0
        private void AddScritturaPartitaDoppia(Conto contoContropartita, Scrittura scrittura)
        {
            //mi serve per impostare il nome del campo contropartita su ogni scrittura
            //presente sul conto
            string nomeContropartita = contoContropartita.Description;

            scrittura.Contropartita   = nomeContropartita;
            scrittura.IdContropartita = contoContropartita.Id;

            //aggiungo l'elemento alla lista
            _sublist.Add(scrittura);
            //aggiungo l'elemnto alla cassa
            Scrittura s = new Scrittura(scrittura, Conto.NegateImportoOperazione(this, contoContropartita), _description);

            s.ParentName = contoContropartita.Description;
            //se invece sto inserendo la scrittura
            //di contropartita ne scrivo il conto di contropartita
            s.Contropartita   = this._description;
            s.IdContropartita = this._id;
            contoContropartita.Add(s, contoContropartita, true);
        }
Exemple #4
0
        public IList CreateDtoItemsListAtDate(Rendiconto rendiconto, bool registerSaldiInizialiBanca, DateTime date)
        {
            IList items = new ArrayList();


            FillDTORendicontoItemListAtDate(items, rendiconto, 0, date);


            //recupero dagli items i saldi iniziali delle banche
            //tramite i relativi id
            Conto banca1 = (Conto)rendiconto.Bilancio.FindNodeById("A.D.2.a");
            Conto banca2 = (Conto)rendiconto.Bilancio.FindNodeById("A.D.2.b");
            Conto banca3 = (Conto)rendiconto.Bilancio.FindNodeById("A.D.2.c");
            Conto banca4 = (Conto)rendiconto.Bilancio.FindNodeById("A.D.2.d");
            Conto banca5 = (Conto)rendiconto.Bilancio.FindNodeById("A.D.2.e");
            Conto banca6 = (Conto)rendiconto.Bilancio.FindNodeById("A.D.2.f");
            Conto cassa  = (Conto)rendiconto.Bilancio.FindNodeById("A.D.1");

            DTORendicontoItem i1 = CreateItemForSaldiIniziali(banca1.Id, banca1.SaldoIniziale);
            DTORendicontoItem i2 = CreateItemForSaldiIniziali(banca2.Id, banca2.SaldoIniziale);
            DTORendicontoItem i3 = CreateItemForSaldiIniziali(banca3.Id, banca3.SaldoIniziale);
            DTORendicontoItem i4 = CreateItemForSaldiIniziali(banca4.Id, banca4.SaldoIniziale);
            DTORendicontoItem i5 = CreateItemForSaldiIniziali(banca5.Id, banca5.SaldoIniziale);
            DTORendicontoItem i6 = CreateItemForSaldiIniziali(banca6.Id, banca6.SaldoIniziale);

            DTORendicontoItem cas = CreateItemForSaldiIniziali(cassa.Id, cassa.SaldoIniziale);

            items.Add(i1);
            items.Add(i2);
            items.Add(i3);
            items.Add(i4);
            items.Add(i5);
            items.Add(i6);
            items.Add(cas);

            return(items);
        }
Exemple #5
0
 public override void Add(Scrittura part, Conto cassa, bool partitaDoppia)
 {
     throw new InvalidOperationException("Tentativo di aggiungere sottoelementi ad un conto gestito a saldo");
 }
Exemple #6
0
        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);
        }
Exemple #7
0
        private static DirezioneOperazione CalcolaDirezioneOperazione(Conto conto, Conto contropartita)
        {
            if (conto == null)
            {
                throw new ArgumentException("conto nullo per il calcolo della direzione di una operazione");
            }
            if (contropartita == null)
            {
                throw new ArgumentException("conto cotropartita nullo per il calcolo della direzione di una operazione");
            }

            //se faccio una operazione nella stessa area  essa risulta sempre verticale
            if (conto.AreaDiBilancio.Equals(contropartita.AreaDiBilancio))
            {
                return(DirezioneOperazione.Verticale);
            }


            //tutte le scritture "Strettamente verticali " e non oblique sono definite verticali
            //altrimenti saranno definite orizzontali
            if (conto.AreaDiBilancio == "A" && contropartita.AreaDiBilancio == "S")
            {
                return(DirezioneOperazione.Verticale);
            }
            if (conto.AreaDiBilancio == "S" && contropartita.AreaDiBilancio == "A")
            {
                return(DirezioneOperazione.Verticale);
            }


            if (conto.AreaDiBilancio == "P" && contropartita.AreaDiBilancio == "E")
            {
                return(DirezioneOperazione.Verticale);
            }
            if (conto.AreaDiBilancio == "E" && contropartita.AreaDiBilancio == "P")
            {
                return(DirezioneOperazione.Verticale);
            }

            //in tutti gli altri casi sono operaizoni con una componente orizzontale
            return(DirezioneOperazione.Orizzontale);



            //ricordarsi che la struttura di un bilancio tipico è cosi fatta:


            //ATTIVITA                   //PASSIVITA
            //_____________________________________________
            ////Immobilizzaizoni         ////Fondi ammortamenti
            ////Crediti                  ////Debiti
            ////Disponibilita            ////Patrimonio netto
            ////....                     ////....



            //SPESE                      //ENTRATE
            //__________________________________________
            ////Affitti                  ////Ricavi
            ////Spese varie              ////Ricavi diversi
            ////....                     ////....
        }