Example #1
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");
            }
        }
Example #2
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();
            }
        }