public NuovoDocumentoArchiviazione(FascicoloCondominioDTO fascicoloCondominio)
        {
            InitializeComponent();
            inizializza();

            _fascicoloCondominio = fascicoloCondominio;
            _fascicoloImmobiliare = _fascicoloService.GetFascicoloImmobiliare(_fascicoloCondominio.IdFascicoloImmobiliare.GetValueOrDefault());
            setField();
        }
Example #2
0
        public DocumentiUI(FascicoloCondominioDTO fascicolo, CondominioDTO condominio)
        {
            InitializeComponent();

            _fascicolo = fascicolo;
            _controlDocument = new DocumentiUC(_fascicolo, condominio) { Dock = DockStyle.Fill };
            _controlDocument.UpdateDocumento += controlDocumentUpdateDocumento;
            Controls.Add(_controlDocument);

            persistWindowComponent1.UserName = Security.Login.Instance.CurrentLogin().LoginName;
        }
Example #3
0
        public FascicoloCondominioDTO[] GetAllFC()
        {
            try
            {
                var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
                var lista = daoFactory.GetFascicoloCondominioDao().GetAll();
                var fascicoliCondominio = new FascicoloCondominioDTO[lista.Count];

                var index = 0;
                foreach (var fascicoloCond in lista)
                {
                    fascicoliCondominio[index] = setFascicoloCondominioDto(fascicoloCond);
                    index++;
                }

                return fascicoliCondominio;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nell'aggiornamento del fascicolo condominio - {0}", ex, Library.Utility.GetMethodDescription());
                throw;
            }
        }
Example #4
0
 public DocumentiUC(FascicoloCondominioDTO fascicolo, CondominioDTO condominio)
 {
     InitializeComponent();
     _fascicolo = fascicolo;
     _condominio = condominio;
 }
Example #5
0
        private void contextMenuStrip1ItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            if (e.ClickedItem.Name == "spostaFascicoloToolStripMenuItem")
            {
                if (_documentoClick != null && _documentoClick.ID > 0)
                {
                    var form = new SceltaFascicoloCondominioUI(_condominio.ID);
                    if(form.ShowDialog() == DialogResult.OK)
                    {
                        var message = getFascicoloService().SpostaDocumentoFascicolo(_documentoClick, _fascicolo, form.FascicoloSelezionato);
                        if (string.IsNullOrEmpty(message))
                        {
                            _fascicolo = getFascicoloService().GetFascicolo(_fascicolo.ID);
                            documentoBindingSource.DataSource = _fascicolo.Documenti;
                            CommonMessages.DisplayComplete("Il documento " + _documentoClick.Descrizione + " è stato correttamente spostato.");
                            OnUpdateDocumento(new UpdateDocumentoArgs(_documentoClick, _fascicolo));
                        }
                        else
                            CommonMessages.DisplayWarning("Si sono verificati dei problemi durante lo spostamento del documento " + _documentoClick.Descrizione + "." + Environment.NewLine + message);
                    }

                    form.Dispose();
                }
            }
            else if (e.ClickedItem.Name == "abilitaCacheToolStripMenuItem")
            {
                if (_documentoClick != null && _documentoClick.ID > 0)
                {
                    var message = getDocumentoService().SetCache(_documentoClick, true);
                    if(string.IsNullOrEmpty(message))
                        _documentoClick.NoCache = false;
                    else
                        CommonMessages.DisplayWarning("Si sono verificati dei problemi nella abilitazione della cache del documento:" + Environment.NewLine + message);
                }
            }
            else if (e.ClickedItem.Name == "disabilitaCacheToolStripMenuItem")
            {
                if (_documentoClick != null && _documentoClick.ID > 0)
                {
                    var message = getDocumentoService().SetCache(_documentoClick, false);
                    if (string.IsNullOrEmpty(message))
                        _documentoClick.NoCache = true;
                    else
                        CommonMessages.DisplayWarning("Si sono verificati dei problemi nella disabilitazione della cache del documento:" + Environment.NewLine + message);
                }
            }
        }
Example #6
0
 public UpdateDocumentoArgs(DocumentoDTO documento, FascicoloCondominioDTO fascicolo)
 {
     Documento = documento;
     Fascicolo = fascicolo;
 }
Example #7
0
 public string SpostaDocumentoFascicolo(DocumentoDTO documento, FascicoloCondominioDTO fascicoloOld, FascicoloCondominioDTO fascicoloNew)
 {
     if (documento != null && fascicoloOld != null && fascicoloNew != null)
     {
         var result = GetServiceClient().SpostaDocumentoFascicolo(documento.ID, fascicoloOld.ID, fascicoloNew.ID, GetUserInfo());
         CloseService();
         return result;
     }
     return null;
 }
Example #8
0
 // Costruttore richiamato solo per il salvataggio di documenti relativi a fascicoli
 public ImportazioneDocumento(byte[] DocFascicolo, string fileName, string descrizioneDocumento, FascicoloCondominioDTO fascicolo)
 {
     _docFascicolo = DocFascicolo;
     _fileName = fileName;
     _fascicolo = fascicolo;
     _descrizioneDocumento = descrizioneDocumento;
     InitializeComponent();
     this.Load += new EventHandler(ImportazioneDocumentoUI_Load);
     DialogResult = DialogResult.OK;
     this.Text = "Salvataggio Documento";
     this.lblPrompt.Text = "Salvataggio del documento in corso.\r\nSi prega di attendere.";
 }
Example #9
0
 public int ManageFCDomainEntity(FascicoloCondominioDTO dto)
 {
     try
     {
         return manageFc(dto).ID;
     }
     catch (Exception ex)
     {
         _log.ErrorFormat("Errore nell'aggiornamento del fascicolo condominio - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), dto.ID);
         throw;
     }
 }
Example #10
0
        private FascicoloCondominio manageFc(FascicoloCondominioDTO fascicoloCondDTO)
        {
            FascicoloCondominio cond = null;
            bool result;

            // Controllo sullo stato U, I
            switch (fascicoloCondDTO.Stato.ToUpper())
            {
                case "U":
                    result = update(fascicoloCondDTO, out cond);

                    if (!result)
                        throw new Exception("Il dato sul database è più recente di quello utilizzato");
                    break;
                case "I":
                    result = insert(fascicoloCondDTO, out cond);

                    if (!result)
                        throw new Exception("Impossibile scrivere sul database");
                    break;
            }
            return cond;
        }
Example #11
0
        private bool insert(FascicoloCondominioDTO fcDto, out FascicoloCondominio fc)
        {
            var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);

            try
            {
                fc = new FascicoloCondominio(daoFactory.GetFascicoloImmobiliareDao().GetById(fcDto.IdFascicoloImmobiliare.GetValueOrDefault(), false), daoFactory.GetCondominioDao().GetById(fcDto.IdCondominio.GetValueOrDefault(), false)) {Necessario = fcDto.Necessario, Presente = fcDto.Presente};
                
                //Documenti
                fc.Documenti.Clear();
                foreach (var t in fcDto.Documenti)
                {
                    if (t != null)
                    {
                        int? id = t.ID;
                        if (t.Stato.ToUpper() == "U" || t.Stato.ToUpper() == "I")
                            id = getDocumentoRepository().ManageDomainEntity(t, fc.CondominioRiferimento.Azienda.ID);

                        var doc = daoFactory.GetDocumentoDao().Find(id.GetValueOrDefault(), false);
                        if (doc != null)
                            fc.Documenti.Add(doc);
                        else
                        {
                            _log.WarnFormat("Documento non trovato - {0} - documento:{1}", Library.Utility.GetMethodDescription(), id);
                        }
                    }
                }

                daoFactory.GetFascicoloCondominioDao().SaveOrUpdate(fc);
            }
            catch (Exception ex)
            {
                
                _log.Error("Errore nell'inserimento del fascicolo condominio: " + Library.Utility.GetMethodDescription() + " - id:" + fcDto.ID, ex);
                throw;
            }
            return true;
        }
Example #12
0
        private bool update(FascicoloCondominioDTO fcDto, out FascicoloCondominio fc)
        {
            fc = null;
            var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); 

            try
            {
                fc = daoFactory.GetFascicoloCondominioDao().GetById(fcDto.ID, false);

                // Condizione necessaria per il controllo del fatto che sul DB ho una versione uguale o più vecchia
                // Per ora è troppo complicato gestire modifiche contemporanee.... ammetto sempre la modifica
                //if (fcDto.Version == fc.Version || true)
                //{
                    fc.Necessario = fcDto.Necessario;
                    fc.Presente = fcDto.Presente;

                    var condominio = daoFactory.GetCondominioDao().GetById(fcDto.IdCondominio.GetValueOrDefault(), false);

                    //Documenti
                    var indexDocumenti = 0;
                    fc.Documenti.Clear();
                    while (indexDocumenti < fcDto.Documenti.Length)
                    {
                        if (fcDto.Documenti[indexDocumenti] != null)
                        {
                            int? id = fcDto.Documenti[indexDocumenti].ID;
                            if (fcDto.Documenti[indexDocumenti].Stato.ToUpper() == "U" || fcDto.Documenti[indexDocumenti].Stato.ToUpper() == "I")
                                id = getDocumentoRepository().ManageDomainEntity(fcDto.Documenti[indexDocumenti], condominio.Azienda.ID);

                            var doc = daoFactory.GetDocumentoDao().Find(id.GetValueOrDefault(), false);
                            if(doc != null)
                                fc.Documenti.Add(doc);
                            else
                            {
                                _log.WarnFormat("Documento non trovato - {0} - documento:{1}", Library.Utility.GetMethodDescription(), id);
                            }
                        }
                        indexDocumenti++;
                    }

                    daoFactory.GetFascicoloCondominioDao().Update(fc);
                //}
                //else
                //{
                //    // Eccezione: Sul db c'è qualche cosa di più nuovo.
                //    _log.Error("Errore nel salvataggio del Fascicolo Condominio id:" + fcDto.ID.ToString() + " - il dato sul db è più recente di quello che si vuole salvare");
                //}
            }
            catch (Exception ex)
            {
                
                _log.Error("Errore nel salvataggio del Fascicolo Condominio: " + Library.Utility.GetMethodDescription() + " - id:" + fcDto.ID, ex);
                throw;
            }
            
            return true;
        }
Example #13
0
        private static FascicoloCondominioDTO setFascicoloCondominioDto(FascicoloCondominio fascicoloCond)
        {
            var dto = new FascicoloCondominioDTO
            {
                ID = fascicoloCond.ID,
                Necessario = fascicoloCond.Necessario,
                Presente = fascicoloCond.Presente,
                IdCondominio = fascicoloCond.CondominioRiferimento.ID,
                DescrizioneCondominio = fascicoloCond.CondominioRiferimento.Descrizione,
                Version = fascicoloCond.Version
            };

            var documenti = new DocumentoDTO[fascicoloCond.Documenti.Count];
            var index = 0;
            foreach (var documento in fascicoloCond.Documenti)
            {
                documenti[index] = setDocumentoDto(documento);
                index++;
            }
            dto.Documenti = documenti;

            return dto;
        }
Example #14
0
        public FascicoloCondominioDTO[] GetFascicoliCByCondominio(int idCondominio)
        {
            try
            {
                var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
                var lista = daoFactory.GetCondominioDao().GetById(idCondominio, false).Fascicolo;
                var fascicoli = new FascicoloCondominioDTO[lista.Count];

                var index = 0;
                foreach (var fascicolo in lista)
                {
                    fascicoli[index] = setFascicoloCondominioDto(fascicolo);
                    index++;
                }

                return fascicoli;
            }
            catch (Exception ex)
            {
                
                _log.Error("Errore nel caricamento dei fascicoli: " + Library.Utility.GetMethodDescription() + " - idCondominio:" + idCondominio, ex);
                throw;
            }
        }
Example #15
0
		public int SetFascicolo(FascicoloCondominioDTO fascicolo, UserInfo userinfo)
		{
			var windsorRep = new WindsorConfigRepository();
			try
			{
				windsorRep.BeginTransaction(userinfo);
                var repo = new FascicoloRepository(userinfo, windsorRep);
				int item = repo.ManageFCDomainEntity(fascicolo);
				windsorRep.Commit();
				return item;
			}
			catch (Exception ex)
			{

				_log.Error("Errore il salvataggio del fascicolo " + Utility.GetMethodDescription() + " - id:" + fascicolo.ID.ToString(), ex);
				windsorRep.Rollback();
				throw;
			}
		}
        public IList<FascicoloCondominioDTO> GetDataSourceFascicolo(int idCondominio)
        {

            try
            {
                _condominio = _daoFactory.GetCondominioDao().GetById(idCondominio, false);
                var fascicolo = _daoFactory.GetFascicoloImmobiliareDao().GetByAzienda(_condominio.Azienda.ID);
                _fascicoliCond = new List<FascicoloCondominioDTO>(fascicolo.Count);

                foreach (var dettaglioFascicolo in fascicolo)
                {
                    var fascicoloCondominio = _daoFactory.GetFascicoloCondominioDao().GetByFascicoloImmobiliareCondominio(dettaglioFascicolo, _condominio);
                    var insertVersion = 0;
                    if (fascicoloCondominio == null)
                    {
                        fascicoloCondominio = new FascicoloCondominio(dettaglioFascicolo, _condominio) {Necessario = true, Presente = false};
                        _daoFactory.GetFascicoloCondominioDao().SaveOrUpdate(fascicoloCondominio);
                        insertVersion = 1;
                    }
                    var fcDTO = new FascicoloCondominioDTO
                    {
                        Version = fascicoloCondominio.Version + insertVersion,
                        IdFascicoloImmobiliare = fascicoloCondominio.DettaglioFascicolo.ID,
                        Descrizione = fascicoloCondominio.DettaglioFascicolo.Descrizione,
                        DisplayName = fascicoloCondominio.DettaglioFascicolo.Codice + " - " + fascicoloCondominio.DettaglioFascicolo.Descrizione,
                        IdCondominio = fascicoloCondominio.CondominioRiferimento.ID,
                        DescrizioneCondominio = fascicoloCondominio.CondominioRiferimento.Descrizione,
                        Necessario = fascicoloCondominio.Necessario,
                        Presente = fascicoloCondominio.Presente,
                        DescrizioneBreve = fascicoloCondominio.DettaglioFascicolo.DescrizioneBreve,
                        ID = fascicoloCondominio.ID
                    };
                    if (fascicoloCondominio.Documenti != null)
                        fcDTO.NumDocumenti = fascicoloCondominio.Documenti.Count;
                    DocumentoDTO[] documenti = null;
                    if (fascicoloCondominio.Documenti != null)
                        documenti = new DocumentoDTO[fascicoloCondominio.Documenti.Count];

                    var index = 0;
                    if (fascicoloCondominio.Documenti != null)
                    {
                        foreach (var documento in fascicoloCondominio.Documenti)
                        {
                            if (documenti != null)
                            {
                                documenti[index] = new DocumentoDTO
                                {
                                    Descrizione = documento.Descrizione,
                                    ID = documento.ID,
                                    IdContratto = documento.ContrattoRiferimento != null ? documento.ContrattoRiferimento.ID : 0,
                                    FileName = documento.FileName,
                                    Checksum = documento.Checksum,
                                    FileExtension = documento.FileExtension,
                                    VisibileCondomino = documento.VisibileCondomino,
                                    NoCache = documento.NoCache,
                                    DataCreazione = documento.DataInserimento.GetValueOrDefault(),
                                    IdentificativoArchiviazioneOttica = _archiviazioneOtticaService.GetIdentificativoArchiviazione(documento, _condominio, false)
                                };
                            }
                            index++;
                        }
                    }
                    fcDTO.Documenti = documenti;
                    _fascicoliCond.Add(fcDTO);
                }

                return _fascicoliCond;
            }
            catch (Exception ex)
            {
                
                _log.Fatal("Errore inaspettato durante la lettura dei fascicoli: GetDataSourceFascicolo - " + Library.Utility.GetMethodDescription(), ex);
            }

            return _fascicoliCond;
        }