示例#1
0
        public void RemoveScrittura(ScrittureDTO scrittura)
        {
            Conto c = _bilancio.FindNodeById(scrittura.ParentId) as Conto;

            if (c == null)
            {
                throw new InvalidOperationException("Tentativo di rimuovere una scrittura ad un elemento diverso da un conto");
            }

            Scrittura s = c.FindNodeById(scrittura.Id) as Scrittura;

            if (s == null)
            {
                return;
            }

            //if (s.TipoOperazione == TipoOperazione.Accantonamento)
            //    c.Remove(scrittura.Id, _bilancio.AccantonamentoFinale);
            //else if (s.TipoOperazione == TipoOperazione.Cassa)
            //    c.Remove(scrittura.Id, _bilancio.CassaFinale);
            //else if (s.TipoOperazione == TipoOperazione.Banca1)
            //    c.Remove(scrittura.Id, _bilancio.Banca1Finale);
            //else if (s.TipoOperazione == TipoOperazione.Banca2)
            //    c.Remove(scrittura.Id, _bilancio.Banca2Finale);
            //else if (s.TipoOperazione == TipoOperazione.Banca3)
            //    c.Remove(scrittura.Id, _bilancio.Banca3Finale);
            //else
            c.Remove(scrittura.Id, _bilancio);//gestione della cancellazione scritture di contropartita

            RaiseChangeEvent();
        }
示例#2
0
        private void AddScrittura(string idConto, ScrittureDTO scrittura, Conto contropartita)
        {
            if (contropartita == null)
            {
                throw new InvalidOperationException("Contropartita nulla");
            }

            Conto c = _bilancio.FindNodeById(idConto) as Conto;

            if (c == null)
            {
                throw new InvalidOperationException("Tentativo di aggingere una scrittura ad un elemento diverso da un conto");
            }


            //prima di aggiungere la scrittura devo eseguire una validazione sulle possibili operazioni di cassa
            ValidateOperazioniDiuCassa(c, contropartita, scrittura.Importo);


            Scrittura s = new Scrittura(idConto);

            // s.TipoOperazione = (TipoOperazione)Enum.Parse(typeof(TipoOperazione), scrittura.TipoOperazione);
            s.Importo      = Convert.ToDouble(scrittura.Importo);
            s.Causale      = scrittura.Causale;
            s.Date         = scrittura.Date.Date;
            s.NumeroPezza  = scrittura.NumeroPezza;
            s.ParentName   = c.Description;
            s.Riferimento1 = scrittura.Riferimento1;
            s.Riferimento2 = scrittura.Riferimento2;
            s.Riferimento3 = scrittura.Riferimento3;

            //if (s.TipoOperazione == TipoOperazione.Cassa)
            //    c.Add(s, _bilancio.CassaFinale, false);
            //else if (s.TipoOperazione == TipoOperazione.Accantonamento)
            //    c.Add(s, _bilancio.AccantonamentoFinale, false);
            //else if (s.TipoOperazione == TipoOperazione.Banca1)
            //    c.Add(s, _bilancio.Banca1Finale, false);
            //else if (s.TipoOperazione == TipoOperazione.Banca2)
            //    c.Add(s, _bilancio.Banca2Finale, false);
            //else if (s.TipoOperazione == TipoOperazione.Banca3)
            //    c.Add(s, _bilancio.Banca3Finale, false);
            //else
            c.Add(s, contropartita, false);

            scrittura.ParentId        = c.Id;
            scrittura.ParentName      = c.Description;
            scrittura.Contropartita   = s.Contropartita;
            scrittura.IdContropartita = s.IdContropartita;
            scrittura.Id = s.Id;

            RaiseChangeEvent();
        }
示例#3
0
        public static SortableBindingList <ScrittureDTO> ConvertScritture(IList scritture)
        {
            SortableBindingList <ScrittureDTO> s = new SortableBindingList <ScrittureDTO>();

            foreach (Scrittura item in scritture)
            {
                ScrittureDTO dto = ConvertToScritturaDTO(item);


                s.Add(dto);
            }



            return(s);
        }
示例#4
0
        public int  PasteScritture(string toIdConto, IList <ScrittureDTO> list)
        {
            Conto c = _bilancio.FindNodeById(toIdConto) as Conto;

            if (c == null)
            {
                throw new ArgumentException("Id conto non specificato! Impossibile trovare il conto di destinazione.");
            }



            int _pasted = 0;

            foreach (ScrittureDTO item in list)
            {
                //non faccio nulla se il conto di partenza è lo stesso del conto di arrivo
                if (!toIdConto.Equals(item.ParentId))
                {//non faccio nulla se la scrittura è autogenerata
                    if (!item.AutoGenerated)
                    {
                        //BilancioFenealgest.DomainLayer.Conto.TipoConto tipoCTo = Conto.CalculateTipoConto(toIdConto);
                        //BilancioFenealgest.DomainLayer.Conto.TipoConto tipoCFrom = Conto.CalculateTipoConto(item.ParentId);

                        ////se non sto riscrivendo una scrittura in partita doppia tutta su spese o oentrate
                        //if (!(item.TipoOperazione == "Contropartita" && tipoCFrom != tipoCTo))
                        //{
                        //ottengo la scrittura di contropartita prima di cancellarla
                        ScrittureDTO controp = GetScritturaContropartita(item);

                        //rimuovo la scrittura
                        RemoveScrittura(item);

                        //aggiungo la scrittura ad un conto
                        AddScrittura(toIdConto, item, controp.ParentId);
                        //notifico che è necessario un refresh(almeno un elemento è cambiato)
                        _pasted++;
                        //}
                    }
                }
            }

            return(_pasted);
        }
示例#5
0
        public static ScrittureDTO ConvertToScritturaDTO(Scrittura item)
        {
            ScrittureDTO dto = new ScrittureDTO();

            dto.AutoGenerated   = item.AutoGenerated;
            dto.Causale         = item.Causale;
            dto.Date            = item.Date.Date;
            dto.Id              = item.Id;
            dto.Importo         = (decimal)item.Importo;
            dto.NumeroPezza     = item.NumeroPezza;
            dto.TipoOperazione  = item.TipoOperazione.ToString();
            dto.ParentId        = item.ParentId;
            dto.ParentName      = item.ParentName;
            dto.Riferimento1    = item.Riferimento1;
            dto.Riferimento2    = item.Riferimento2;
            dto.Riferimento3    = item.Riferimento3;
            dto.Contropartita   = item.Contropartita;
            dto.IdContropartita = item.IdContropartita;
            return(dto);
        }
示例#6
0
        internal ScrittureDTO GetScritturaContropartita(ScrittureDTO _current)
        {
            //if (_current.TipoOperazione == "Contropartita")
            //{

            //BilancioFenealgest.DomainLayer.Conto.TipoConto c = Conto.CalculateTipoConto(_current.ParentId);
            ////se la contropartita è nulla vuol dire che ho passato l'intero bilancio


            ////*****************************
            ////definisco l'id della classificazione dove ricercare il conto
            //string idClassificazione = "";

            //if (c == BilancioFenealgest.DomainLayer.Conto.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 = _bilancio.FindNodeById(idClassificazione) as Classificazione;


            Conto conto = _bilancio.FindNodeById(_current.IdContropartita) as Conto;

            //cerco la scritttura
            Scrittura s1 = conto.FindNodeById(_current.Id) as Scrittura;

            if (s1 == null)
            {
                throw new Exception("Scrittura di partita doppia non trovata");
            }



            return(ScrittureConverter.ConvertToScritturaDTO(s1));

            //}
            //else
            //{
            //    Conto c;

            //    switch (_current.TipoOperazione)
            //    {
            //        case "Cassa":
            //            c = _bilancio.CassaFinale;
            //            break;
            //        case "Banca2":
            //            c = _bilancio.Banca2Finale;
            //            break;
            //        case "Banca1":
            //            c = _bilancio.Banca1Finale;
            //            break;
            //        case "Banca3":
            //            c = _bilancio.Banca3Finale;
            //            break;
            //        case "Accantonamento":
            //            c = _bilancio.AccantonamentoFinale;
            //            break;
            //        default:
            //            throw new ArgumentException("Tipo operazione sconosciuta!");

            //    }

            //    Scrittura s1 = c.FindNodeById(_current.Id) as Scrittura;

            //    if (s1 == null)
            //        throw new Exception("Scrittura di partita doppia non trovata");



            //    return ScrittureConverter.ConvertToScritturaDTO(s1);
            //}
        }
示例#7
0
        public void UpdateScrittura(ScrittureDTO scrittura, string contropartitaId)
        {
            Conto contropartita = _bilancio.FindNodeById(contropartitaId) as Conto;
            Conto c             = _bilancio.FindNodeById(scrittura.ParentId) as Conto;

            if (c == null)
            {
                throw new InvalidOperationException("Tentativo di aggiornare una scrittura ad un elemento diverso da un conto");
            }

            if (contropartita == null)
            {
                throw new InvalidOperationException("Tentativo di aggiornare una scrittura con contropartita nulla");
            }



            //prima di aggiungere la scrittura devo eseguire una validazione sulle possibili operazioni di cassa
            ValidateOperazioniDiuCassa(c, contropartita, scrittura.Importo);


            Scrittura s = c.FindNodeById(scrittura.Id) as Scrittura;

            if (s == null)
            {
                throw new InvalidOperationException("Tentativo di aggiornare una scrittura non presente nel conto");
            }



            //se si tratta di una scrittura autogenerata
            if (s.AutoGenerated)
            {
                s.Importo     = Convert.ToDouble(scrittura.Importo);
                s.Causale     = scrittura.Causale;
                s.Date        = scrittura.Date.Date;
                s.NumeroPezza = scrittura.NumeroPezza;

                return;
            }

            //verifico preventivamente la possibilità di fare una scrittura in partita doppia sullo
            //stesso conto
            //**********************************
            Conto fin = null;

            //TipoOperazione tip = (TipoOperazione)Enum.Parse(typeof(TipoOperazione), scrittura.TipoOperazione);
            //if (tip == TipoOperazione.Cassa)
            //    fin = _bilancio.CassaFinale;
            //else if (tip == TipoOperazione.Accantonamento)
            //    fin = _bilancio.AccantonamentoFinale;
            //else if (tip == TipoOperazione.Banca1)
            //    fin = _bilancio.Banca1Finale;
            //else if (tip == TipoOperazione.Banca2)
            //    fin = _bilancio.Banca2Finale;
            //else if (tip == TipoOperazione.Banca3)
            //    fin = _bilancio.Banca3Finale;
            //else
            fin = contropartita;

            if (fin != null)
            {
                if (c.Id.Equals(fin.Id))
                {
                    throw new Exception("Impossibile scrivere una scrittura in partita doppia sullo stesso conto!");
                }
            }
            //**********************************



            //a questo punto rimuovo la scrittura precedente
            RemoveScrittura(scrittura);



            //eaggiungo la nuova scrittura
            Scrittura s1 = new Scrittura();

            // s1.TipoOperazione = tip;
            s1.Importo      = Convert.ToDouble(scrittura.Importo);
            s1.Causale      = scrittura.Causale;
            s1.Date         = scrittura.Date.Date;
            s1.NumeroPezza  = scrittura.NumeroPezza;
            s1.Id           = scrittura.Id;
            s1.ParentName   = c.Description;
            s1.Riferimento1 = scrittura.Riferimento1;
            s1.Riferimento2 = scrittura.Riferimento2;
            s1.Riferimento3 = scrittura.Riferimento3;
            //if (s1.TipoOperazione == TipoOperazione.Cassa)
            //    c.Add(s1, _bilancio.CassaFinale, false);
            //else if (s1.TipoOperazione == TipoOperazione.Accantonamento)
            //    c.Add(s1, _bilancio.AccantonamentoFinale, false);
            //else if (s1.TipoOperazione == TipoOperazione.Banca1)
            //    c.Add(s1, _bilancio.Banca1Finale, false);
            //else if (s1.TipoOperazione == TipoOperazione.Banca2)
            //    c.Add(s1, _bilancio.Banca2Finale, false);
            //else if (s1.TipoOperazione == TipoOperazione.Banca3)
            //    c.Add(s1, _bilancio.Banca3Finale, false);
            //else
            c.Add(s1, fin, false);

            scrittura.ParentName    = c.Description;
            scrittura.Contropartita = s1.Contropartita;



            RaiseChangeEvent();
        }
示例#8
0
        public void AddScrittura(string idConto, ScrittureDTO scrittura, string contropartita)
        {
            Conto c = _bilancio.FindNodeById(contropartita) as Conto;

            AddScrittura(idConto, scrittura, c);
        }