예제 #1
0
 /// <summary>
 ///
 /// </summary>
 protected void CheckForRepositoryExpired()
 {
     if (!Directory.Exists(SessionRepositoryFileManager.GetContextRepositoryPath(this.Context)))
     {
         throw new ApplicationException(string.Format("Il repository '{0}' risulta scaduto e non può essere più utilizzato", this.Context.Token));
     }
 }
예제 #2
0
        /// <summary>
        /// Spostamento dei file dal repository di sessione temporaneo
        /// al repository documentale in cui sono stati memorizzati i metadati del documento
        /// </summary>
        /// <param name="schedaDocumento"></param>
        /// <remarks>
        /// L'operazione può essere utilizzata solamente se i metadati del documento
        /// sono stati salvati e se i file eventualmente acquisiti ancora risiedono nel repository temporaneo
        /// </remarks>
        public static void Syncronize(DocsPaVO.documento.SchedaDocumento schedaDocumento)
        {
            if (!string.IsNullOrEmpty(schedaDocumento.systemId) &&
                schedaDocumento.repositoryContext != null)
            {
                SessionRepositoryFileManager fileManager = SessionRepositoryFileManager.GetFileManager(schedaDocumento.repositoryContext);

                DocsPaVO.documento.FileRequest[] versions = (DocsPaVO.documento.FileRequest[])schedaDocumento.documenti.ToArray(typeof(DocsPaVO.documento.FileRequest));
                if (versions.Length > 0)
                {
                    schedaDocumento.documenti = new ArrayList(CopyToRepository(fileManager, versions));
                }

                versions = (DocsPaVO.documento.FileRequest[])schedaDocumento.allegati.ToArray(typeof(DocsPaVO.documento.Allegato));
                if (versions.Length > 0)
                {
                    schedaDocumento.allegati = new ArrayList(CopyToRepository(fileManager, versions));
                }

                // Imposta il repository come scaduto
                fileManager.Delete();

                schedaDocumento.repositoryContext = null;
            }
            else
            {
                throw new ApplicationException("Nessun repository di sessione definito per il documento");
            }
        }
예제 #3
0
        /// <summary>
        /// Rimozione di tutti i file associati al documento
        /// </summary>
        public void RemoveAllFiles()
        {
            this.CheckForRepositoryExpired();

            foreach (FileInfo file in new DirectoryInfo(SessionRepositoryFileManager.GetContextRepositoryPath(this.Context)).GetFiles())
            {
                file.Delete();
            }
        }
예제 #4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="fileManager"></param>
        /// <param name="version"></param>
        /// <returns></returns>
        public static DocsPaVO.documento.FileRequest CopyToRepository(SessionRepositoryFileManager fileManager, DocsPaVO.documento.FileRequest version)
        {
            DocsPaVO.documento.FileRequest result = null;

            version.repositoryContext = null;

            if (fileManager.ExistFile(version))
            {
                // Reperimento del file dal repository di sessione
                DocsPaVO.documento.FileDocumento document = fileManager.GetFile(version);

                // Inserimento del file nel repository documentale
                result = BusinessLogic.Documenti.FileManager.putFile(version, document, fileManager.Context.Owner);
            }
            else
            {
                result = version;
            }

            return(result);
        }
예제 #5
0
        /// <summary>
        /// Rimozione di un allegato
        /// </summary>
        /// <param name="allegato"></param>
        /// <param name="infoUtente"></param>
        public static bool rimuoviAllegato(DocsPaVO.documento.Allegato allegato, DocsPaVO.utente.InfoUtente infoUtente)
        {
            bool retValue = false;

            if (allegato.repositoryContext != null)
            {
                // Rimozione dell'allegato nell'ambito del  repository context
                SessionRepositoryFileManager fm = BusinessLogic.Documenti.SessionRepositoryFileManager.GetFileManager(allegato.repositoryContext);

                // Verifica esistenza file acquisito nel repository context
                if (fm.ExistFile(allegato))
                {
                    fm.RemoveFile(allegato);
                }

                retValue = true;
            }
            else
            {
                // Controllo su stato congelato
                DocumentConsolidation.CanExecuteAction(infoUtente,
                                                       allegato.docNumber,
                                                       DocumentConsolidation.ConsolidationActionsDeniedEnum.RemoveAttatchments, true);

                using (DocsPaDB.TransactionContext transactionContext = new DocsPaDB.TransactionContext())
                {
                    DocsPaDocumentale.Documentale.DocumentManager documentManager = new DocsPaDocumentale.Documentale.DocumentManager(infoUtente);

                    retValue = documentManager.RemoveAttatchment(allegato);

                    if (retValue)
                    {
                        transactionContext.Complete();
                    }
                }
            }

            return(retValue);
        }
예제 #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="fileManager"></param>
        /// <param name="versions"></param>
        /// <returns></returns>
        public static DocsPaVO.documento.FileRequest[] CopyToRepository(SessionRepositoryFileManager fileManager, DocsPaVO.documento.FileRequest[] versions)
        {
            List <DocsPaVO.documento.FileRequest> newVersions = new List <DocsPaVO.documento.FileRequest>();
            string tmpVersionLabel;

            foreach (DocsPaVO.documento.FileRequest version in versions)
            {
                tmpVersionLabel = version.versionLabel;

                version.repositoryContext = null;

                if (fileManager.ExistFile(version))
                {
                    // Reperimento del file dal repository di sessione
                    DocsPaVO.documento.FileDocumento document = fileManager.GetFile(version);

                    // Inserimento del file nel repository documentale
                    DocsPaVO.documento.FileRequest result = BusinessLogic.Documenti.FileManager.putFile(version, document, fileManager.Context.Owner);

                    if (!string.IsNullOrEmpty(tmpVersionLabel) && result != null)
                    {
                        result.versionLabel = tmpVersionLabel;
                    }

                    newVersions.Add(result);

                    // Rimozione del file dal repository di sessione
                    version.repositoryContext = null;
                }
                else
                {
                    newVersions.Add(version);
                }
            }

            return(newVersions.ToArray());
        }
예제 #7
0
        /// <summary>
        /// </summary>
        /// <param name="schedaDoc"></param>
        /// <param name="objSicurezza"></param>
        /// <param name="objRuolo"></param>
        /// <param name="debug"></param>
        /// <returns></returns>
        public static DocsPaVO.documento.SchedaDocumento addDocGrigia(DocsPaVO.documento.SchedaDocumento schedaDoc, DocsPaVO.utente.InfoUtente objSicurezza, DocsPaVO.utente.Ruolo objRuolo)
        {
            logger.Info("BEGIN");
            try
            {
                semProtNuovo.WaitOne();

                // Avvio del contesto transazionale
                using (DocsPaDB.TransactionContext transactionContext = new DocsPaDB.TransactionContext())
                {
                    //SOSTITUISCO IL CARATTERE SPECIALE
                    if (schedaDoc.oggetto.descrizione.Contains("–"))
                    {
                        schedaDoc.oggetto.descrizione = schedaDoc.oggetto.descrizione.Replace("–", "-");
                    }

                    // verifico i dati di ingresso
                    ProtoManager.checkInputData(objSicurezza.idAmministrazione, schedaDoc);
                    logger.Debug("nomeUtente=" + schedaDoc.userId);

                    //add massimo digregorio carica dati protocollatore in schedaProtocollo
                    schedaDoc = getDatiProtocollatore(schedaDoc, objRuolo, objSicurezza);
                    schedaDoc = getDatiCreatore(schedaDoc, objRuolo, objSicurezza);

                    // creo il nuovo documento
                    DocsPaDocumentale.Documentale.DocumentManager documentManager = new DocsPaDocumentale.Documentale.DocumentManager(objSicurezza);

                    DocsPaVO.utente.Ruolo[] ruoliSuperiori;

                    List <DocsPaVO.documento.FileRequest> versions = new List <DocsPaVO.documento.FileRequest>();

                    if (schedaDoc.documenti != null && schedaDoc.documenti.Count > 0)
                    {
                        versions = new List <DocsPaVO.documento.FileRequest>((DocsPaVO.documento.FileRequest[])schedaDoc.documenti.ToArray(typeof(DocsPaVO.documento.FileRequest)));

                        // Ordinamento versioni
                        versions.Sort(
                            delegate(DocsPaVO.documento.FileRequest x, DocsPaVO.documento.FileRequest y)
                        {
                            int versionX, versionY;
                            Int32.TryParse(x.version, out versionX);
                            Int32.TryParse(y.version, out versionY);

                            return(versionX.CompareTo(versionY));
                        }
                            );
                    }

                    if (!documentManager.CreateDocumentoGrigio(schedaDoc, objRuolo, out ruoliSuperiori))
                    {
                        throw new ApplicationException("Errore nella creazione del documento grigio");
                    }
                    else
                    {
                        // Notifica evento documento creato
                        DocsPaDocumentale.Interfaces.IAclEventListener eventsNotification = new DocsPaDocumentale.Documentale.AclEventListener(objSicurezza);

                        eventsNotification.DocumentoCreatoEventHandler(schedaDoc, objRuolo, ruoliSuperiori);

                        // Sincronizzazione repository
                        if (schedaDoc.repositoryContext != null)
                        {
                            SessionRepositoryFileManager fileManager = SessionRepositoryFileManager.GetFileManager(schedaDoc.repositoryContext);

                            // In fase di inserimento di un repository temporaneo,
                            // possono essere creati:
                            // - la prima versione del documento e, qualora sia stato acquisito un file
                            //   e firmato, anche la seconda versione firmata del documento
                            // - la prima versione di n allegati
                            // La prima versione del documento è creata automaticamente con la creazione del documento stesso.
                            // In caso di seconda versione firmata del documento, è necessario procedre alla creazione.
                            foreach (DocsPaVO.documento.FileRequest v in versions)
                            {
                                int version;
                                Int32.TryParse(v.version, out version);

                                DocsPaVO.documento.FileRequest savedVersion = null;

                                if (version > 1)
                                {
                                    // Seconda versione firmata del documento,
                                    // impostazione dell'id del documento di appartenenza
                                    v.docNumber = schedaDoc.docNumber;

                                    // Inserimento delle versioni del documento,
                                    // acquisite oltre alla versione principale
                                    if (!documentManager.AddVersion(v, false))
                                    {
                                        throw new ApplicationException(string.Format("Errore nella creazione della versione {0} del documento con id {1}", version, schedaDoc.systemId));
                                    }

                                    savedVersion = SessionRepositorySyncronizer.CopyToRepository(fileManager, v);

                                    // Inserimento della nuova versione come primo elemento della lista documenti
                                    schedaDoc.documenti.Insert(0, savedVersion);
                                }
                                else
                                {
                                    // La versione principale del documento è già stata creata al momento dell'inserimento,
                                    // pertanto è necessario copiare solamente il file acquisito nel repository
                                    savedVersion = SessionRepositorySyncronizer.CopyToRepository(fileManager, (DocsPaVO.documento.FileRequest)schedaDoc.documenti[0]);

                                    // Aggiornamento istanza documento principale
                                    schedaDoc.documenti[0] = savedVersion;
                                }
                            }

                            if (schedaDoc.allegati != null && schedaDoc.allegati.Count > 0)
                            {
                                // Gli allegati e le rispettive versioni andranno create manualmente
                                foreach (DocsPaVO.documento.Allegato allegato in schedaDoc.allegati)
                                {
                                    string oldVersionLabel = allegato.versionLabel;

                                    // Impostazione del docnumber del documento principale
                                    // cui sarà associato l'allegato
                                    allegato.docNumber = schedaDoc.docNumber;

                                    if (!documentManager.AddAttachment(allegato, "N"))
                                    {
                                        throw new ApplicationException(string.Format("Errore nella creazione dell'allegato {0} del documento con id {1}", allegato.position, schedaDoc.systemId));
                                    }

                                    allegato.versionLabel = oldVersionLabel;
                                }

                                DocsPaVO.documento.FileRequest[] allegati = (DocsPaVO.documento.FileRequest[])schedaDoc.allegati.ToArray(typeof(DocsPaVO.documento.Allegato));

                                if (allegati.Length > 0)
                                {
                                    schedaDoc.allegati = new ArrayList(SessionRepositorySyncronizer.CopyToRepository(fileManager, allegati));
                                }
                            }

                            // Se è presente un repository temporaneo, viene effettuato l'inserimento del file nel repository del documentale
                            // Imposta il repository come scaduto
                            fileManager.Delete();

                            schedaDoc.repositoryContext = null;
                        }
                    }

                    //Richiamo il metodo per il calcolo della atipicità del documento
                    DocsPaDB.Query_DocsPAWS.Documentale documentale = new DocsPaDB.Query_DocsPAWS.Documentale();
                    schedaDoc.InfoAtipicita = documentale.CalcolaAtipicita(objSicurezza, schedaDoc.docNumber, DocsPaVO.Security.InfoAtipicita.TipoOggettoAtipico.DOCUMENTO);

                    if (schedaDoc != null)
                    {
                        // Impostazione della transazione come completata,
                        // solamente se il documento è stato creato correttamente
                        transactionContext.Complete();
                    }
                }
                logger.Info("END");
                return(schedaDoc);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                semProtNuovo.ReleaseMutex();
            }
        }
예제 #8
0
 /// <summary>
 ///
 /// </summary>
 public void Delete()
 {
     Directory.Delete(SessionRepositoryFileManager.GetContextRepositoryPath(this.Context), true);
 }