Example #1
0
        public virtual bool Checkconnection()
        {
            bool retValue = false;

            //loginResult = UserLogin.LoginResult.APPLICATION_ERROR;
            System.Data.DataSet ds = null;
            try
            {
                DocsPaDB.Query_DocsPAWS.Documentale d = new DocsPaDB.Query_DocsPAWS.Documentale();
                d.ExecuteQuery(out ds, "SELECT SYSTEM_ID FROM DPA_AMMINISTRA");
                if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0 &&
                    ds.Tables[0].Rows[0][0] != null)
                {
                    retValue = true;
                }
                else
                {
                    retValue = false;
                }
            }
            catch (Exception ex)
            {
                //AuthenticationException - Exception in com.emc.documentum.fs.rt
                //Exception which is raised when authentication errors occur
                //  loginResult = DocsPaVO.utente.UserLogin.LoginResult.UNKNOWN_DTCM_USER;
                retValue = false;

                logger.Error("errore in checkconnetcion" + ex.Message);
            }

            return(retValue);
        }
Example #2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="ruolo"></param>
        /// <returns></returns>
        public EsitoOperazione InserisciRuolo(OrgRuolo ruolo, bool computeAtipicita)
        {
            DocsPaDB.Query_DocsPAWS.Amministrazione  dbAmm = new DocsPaDB.Query_DocsPAWS.Amministrazione();
            DocsPaVO.amministrazione.EsitoOperazione esito = new DocsPaVO.amministrazione.EsitoOperazione();

            //verifica se il codice è univoco sulla corr_globali
            DocsPaDB.Query_DocsPAWS.AmministrazioneXml obj = new DocsPaDB.Query_DocsPAWS.AmministrazioneXml();
            if (!obj.CheckCountCondition("DPA_CORR_GLOBALI", "UPPER(VAR_CODICE)=UPPER('" + ruolo.Codice + "') AND ID_AMM=" + ruolo.IDAmministrazione))
            {
                esito.Codice      = 1;
                esito.Descrizione = "codice già utilizzato da altro ruolo";
            }
            else
            {
                //verifica se il codice è univoco sulla groups
                if (!obj.CheckCountCondition("GROUPS", "UPPER(GROUP_ID)=UPPER('" + ruolo.Codice + "')"))
                {
                    esito.Codice      = 2;
                    esito.Descrizione = "codice già utilizzato da altro gruppo";
                }
                else
                {
                    if (!dbAmm.AmmInsNuovoRuolo(ruolo))
                    {
                        esito.Codice      = 3;
                        esito.Descrizione = "si è verificato un errore: inserimento del ruolo";
                    }

                    //verifica se si vuole disabilitare alla ricezione delle trasmissioni un ruolo di riferimento
                    if (ruolo.DiRiferimento.ToString().Equals("1") && ruolo.DisabledTrasm.ToString().Equals("1"))
                    {
                        esito.Codice      = 4;
                        esito.Descrizione = "Impossibile disabilitare alla ricezione delle trasmissioni un ruolo di riferimento";
                    }
                }
            }

            // Se è richiesto il calcolo dell'atipicità, viene richiamata la procedura
            if (esito.Codice == 0 && computeAtipicita)
            {
                try
                {
                    using (DocsPaDB.Query_DocsPAWS.Documentale doc = new DocsPaDB.Query_DocsPAWS.Documentale())
                        doc.CalcolaAtipicitaRuoliSottoposti(ruolo);
                }
                catch (Exception e)
                {
                    esito.Codice      = 5;
                    esito.Descrizione = "Errore durante il calcolo di atipicità su documenti e fascicoli dei ruoli sottoposti";
                }
            }

            obj   = null;
            dbAmm = null;

            return(esito);
        }
Example #3
0
        /// <summary>
        /// Metodo per l'estensione di visibilità ai ruoli superiori di un ruolo
        /// </summary>
        /// <param name="idAmm">Id dell'amministrazione</param>
        /// <param name="idGroup">Id del gruppo di cui estendere la visibilità</param>
        /// <param name="extendScope">Scope di estensione</param>
        /// <param name="copyIdToTempTable">True se bisogna copiare gli id id dei documenti e fascicoli in una tabella tamporanea per l'allineamento asincrono della visibilità</param>
        /// <returns>Esito dell'operazione</returns>
        public EsitoOperazione ExtendVisibilityToHigherRoles(
            String idAmm,
            String idGroup,
            DocsPaVO.amministrazione.SaveChangesToRoleRequest.ExtendVisibilityOption extendScope)
        {
            EsitoOperazione retVal = new EsitoOperazione();

            using (DocsPaDB.Query_DocsPAWS.Documentale doc = new DocsPaDB.Query_DocsPAWS.Documentale())
            {
                bool result = doc.ExtendVisibilityToHigherRoles(idAmm, idGroup, extendScope, false);

                retVal.Codice      = result ? 0 : -1;
                retVal.Descrizione = result ? String.Empty : "Si è verificato un errore durante l'estensione della visibilità di documenti e fascicoli ai superiori gerarchici";
            }


            return(retVal);
        }
Example #4
0
        /// <summary>
        /// Inserimento dei metadati di un file inserito in etdocs
        /// </summary>
        /// <param name="fileRequest"></param>
        /// <param name="fileContent"></param>
        /// <param name="fileExtension"></param>
        protected virtual void SetFileAsInserted(FileRequest fileRequest, byte[] fileContent, string originalFileName)
        {
            // Aggiornamento tabella COMPONENTS
            string varImpronta = DocsPaUtils.Security.CryptographyManager.CalcolaImpronta256(fileContent);

            DocsPaDB.Query_DocsPAWS.Documenti doc = new DocsPaDB.Query_DocsPAWS.Documenti();

            doc.UpdateVersion(fileRequest);
            doc.UpdateComponents(fileRequest.fileSize, varImpronta, fileRequest.versionId, fileRequest.docNumber);

            string fileExtension = null;

            try
            {
                fileExtension = System.IO.Path.GetExtension(fileRequest.fileName).Replace(".", string.Empty);

                doc.UpdateComponentsExt(fileExtension, fileRequest.versionId, fileRequest.docNumber);
            }
            catch (Exception ex)
            {
                logger.Debug("Si è verificato un errore nel reperimento del fileName da metodo GetExtension", ex);
            }

            DocsPaDB.Query_DocsPAWS.Documentale documentale = new DocsPaDB.Query_DocsPAWS.Documentale();
            documentale.UpdateFileName(fileRequest.fileName, fileRequest.versionId);
            DocsPaDB.Query_DocsPAWS.Documenti documenti = new DocsPaDB.Query_DocsPAWS.Documenti();
            documenti.UpdateComponentsOfn(originalFileName, fileRequest.versionId, fileRequest.docNumber);


            //Aggiornamento tabella PROFILE
            int version;

            if (Int32.TryParse(fileRequest.version, out version))
            {
                if (version > 0)
                {
                    doc.SetImg(fileRequest.docNumber);
                }
            }
        }
Example #5
0
        /// <summary>
        /// Inserimento dei metadati di un file inserito in etdocs
        /// </summary>
        /// <param name="fileRequest"></param>
        /// <param name="fileContent"></param>
        /// <param name="fileExtension"></param>
        protected virtual void SetFileAsInserted(FileRequest fileRequest, byte[] fileContent)
        {
            // Aggiornamento tabella COMPONENTS
            string varImpronta = DocsPaUtils.Security.CryptographyManager.CalcolaImpronta256(fileContent);

            DocsPaDB.Query_DocsPAWS.Documenti doc = new DocsPaDB.Query_DocsPAWS.Documenti();
            doc.UpdateComponents(fileRequest.fileSize, varImpronta, fileRequest.versionId, fileRequest.docNumber);

            DocsPaDB.Query_DocsPAWS.Documentale documentale = new DocsPaDB.Query_DocsPAWS.Documentale();
            documentale.UpdateFileName(fileRequest.fileName, fileRequest.versionId);

            //Aggiornamento tabella PROFILE
            int version;

            if (Int32.TryParse(fileRequest.version, out version))
            {
                if (version > 0)
                {
                    doc.SetImg(fileRequest.docNumber);
                }
            }
        }
Example #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="infoUtente"></param>
        /// <param name="copyVisibility"></param>
        /// <returns></returns>
        public EsitoOperazione CopyVisibility(DocsPaVO.utente.InfoUtente infoUtente, DocsPaVO.Security.CopyVisibility copyVisibility)
        {
            EsitoOperazione esitoOperazione = new EsitoOperazione();

            using (DocsPaDB.TransactionContext transactionContext = new DocsPaDB.TransactionContext())
            {
                try
                {
                    DocsPaDB.Query_DocsPAWS.Documentale documentale = new DocsPaDB.Query_DocsPAWS.Documentale();
                    esitoOperazione = documentale.CopyVisibility(infoUtente, copyVisibility);
                    transactionContext.Complete();
                    return(esitoOperazione);
                }
                catch (Exception e)
                {
                    logger.Debug("Errore in OrganigrammaManager  - metodo: CopyVisibility", e);
                    esitoOperazione.Codice      = -1;
                    esitoOperazione.Descrizione = "Problemi durante la copia della visibilità ETDOCS. Cosultare il file di log.";
                    return(esitoOperazione);
                }
            }
        }
Example #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();
            }
        }
Example #8
0
        /// <summary>
        /// </summary>
        /// <param name="schedaDoc"></param>
        /// <param name="objSicurezza"></param>
        /// <param name="debug"></param>
        /// <returns></returns>
        public static DocsPaVO.documento.SchedaDocumento save(DocsPaVO.utente.InfoUtente infoUtente, DocsPaVO.documento.SchedaDocumento schedaDoc, bool enableUffRef, out bool daAggiornareUffRef, DocsPaVO.utente.Ruolo ruolo)
        {
            logger.Info("BEGIN");

            //SOSTITUISCO IL CARATTERE SPECIALE
            if (schedaDoc.oggetto.descrizione.Contains("–"))
            {
                schedaDoc.oggetto.descrizione = schedaDoc.oggetto.descrizione.Replace("–", "-");
            }

            // Controllo su stato congelato del documento
            DocumentConsolidation.CanChangeMetadata(infoUtente, schedaDoc, true);

            DocsPaVO.documento.SchedaDocumento savedDocument = null;

            daAggiornareUffRef = false;
            string incestino = string.Empty;

            //controllo se doc in cestino
            incestino = BusinessLogic.Documenti.DocManager.checkdocInCestino(schedaDoc.docNumber);

            if (incestino != "" &&
                incestino == "1")
            {
                throw new Exception("Il documento è stato rimosso, non è più possibile modificarlo");
            }

            //Verifico se il documento è in libro firma e se è prevista la repertoriazione del documento
            #region CHECK_LIBRO_FIRMA
            if (LibroFirma.LibroFirmaManager.IsDocInLibroFirma(schedaDoc.docNumber))
            {
                bool daRepertoriare = false;
                if (schedaDoc.template != null && !string.IsNullOrEmpty(schedaDoc.template.ID_TIPO_ATTO) && schedaDoc.template.ELENCO_OGGETTI != null && schedaDoc.template.ELENCO_OGGETTI.Count > 0)
                {
                    DocsPaVO.ProfilazioneDinamica.OggettoCustom ogg = (from o in schedaDoc.template.ELENCO_OGGETTI.Cast <DocsPaVO.ProfilazioneDinamica.OggettoCustom>()
                                                                       where o.TIPO.DESCRIZIONE_TIPO.Equals("Contatore") && o.REPERTORIO.Equals("1") &&
                                                                       o.CONTATORE_DA_FAR_SCATTARE && string.IsNullOrEmpty(o.VALORE_DATABASE)
                                                                       select o).FirstOrDefault();
                    if (ogg != null && !LibroFirma.LibroFirmaManager.IsTitolarePassoInAttesa(schedaDoc.docNumber, infoUtente, DocsPaVO.LibroFirma.Azione.DOCUMENTO_REPERTORIATO))
                    {
                        throw new Exception("Non è possibile procedere con la repertoriazione poichè il documento è in Libro Firma");
                    }
                }
            }
            #endregion

            // Contesto transazionale
            using (DocsPaDB.TransactionContext transactionContext = new DocsPaDB.TransactionContext())
            {
                if (schedaDoc.repositoryContext != null)
                {
                    // Cerazione del documento grigio se è stata fornita una scheda documento in repository context
                    schedaDoc = addDocGrigia(schedaDoc, infoUtente, ruolo);
                }

                if (schedaDoc.systemId != null && !schedaDoc.systemId.Equals(""))
                {
                    if (schedaDoc.predisponiProtocollazione || (schedaDoc.protocollo != null && (schedaDoc.protocollo.segnatura == null || (schedaDoc.protocollo.segnatura != null && schedaDoc.protocollo.segnatura == "")) && schedaDoc.protocollo.ModUffRef == true && enableUffRef))
                    {
                        savedDocument = predisponiAllaProtocollazione(infoUtente, schedaDoc);
                    }
                    else
                    {
                        savedDocument = salvaModifiche(infoUtente, schedaDoc, enableUffRef, out daAggiornareUffRef);
                    }
                }
                else
                {
                    savedDocument = schedaDoc;
                }

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

                if (savedDocument != null)
                {
                    // La transazione viene completata, se le modifiche sono state effettuate correttamente
                    transactionContext.Complete();
                }
            }
            logger.Info("END");
            return(savedDocument);
        }
Example #9
0
 public static DocsPaVO.Security.InfoAtipicita GetInfoAtipicita(DocsPaVO.utente.InfoUtente infoUtente, DocsPaVO.Security.InfoAtipicita.TipoOggettoAtipico tipoOggetto, string idDocOrFasc)
 {
     DocsPaDB.Query_DocsPAWS.Documentale documentale = new DocsPaDB.Query_DocsPAWS.Documentale();
     return(documentale.GetInfoAtipicita(infoUtente, tipoOggetto, idDocOrFasc));
 }
Example #10
0
        public static bool AddVersion(DocsPaVO.documento.FileRequest fileRequest, bool daInviare, InfoUtente infoUtente)
        {
            bool result = true;

            bool   update = false;
            string oldApp = null;

            System.Data.DataSet ds;
            DocsPaDB.Query_DocsPAWS.Documenti doc = new DocsPaDB.Query_DocsPAWS.Documenti();

            try
            {
                if (fileRequest.applicazione != null)
                {
                    if (fileRequest.applicazione.systemId == null)
                    {
                        logger.Debug("sysid vuoto");

                        DocsPaVO.documento.Applicazione res = new DocsPaVO.documento.Applicazione();
                        doc.GetExt(fileRequest.applicazione.estensione, ref res);

                        fileRequest.applicazione = res;
                    }
                    logger.Debug("Update della tabella profile");
                    string param = "(APPLICATION is NULL OR APPLICATION != " + fileRequest.applicazione.systemId + ") AND DOCNUMBER=" + fileRequest.docNumber;
                    doc.GetApplication(out oldApp, fileRequest.docNumber, fileRequest.applicazione.systemId, param);

                    update = true;
                }

                DocsPaDB.Query_DocsPAWS.Documentale documentale = new DocsPaDB.Query_DocsPAWS.Documentale();
                documentale.AddVersion(ref fileRequest, infoUtente.idPeople, infoUtente.userId);

                //ESTRAZIONE DEL FILENAME, VERSION, LASTEDITTIME
                doc.SetCompVersions(fileRequest.versionId, fileRequest.docNumber, out ds);

                fileRequest.fileName        = ds.Tables["VERS"].Rows[0]["PATH"].ToString();
                fileRequest.version         = ds.Tables["VERS"].Rows[0]["VERSION"].ToString();
                fileRequest.subVersion      = ds.Tables["VERS"].Rows[0]["SUBVERSION"].ToString();
                fileRequest.versionLabel    = ds.Tables["VERS"].Rows[0]["VERSION_LABEL"].ToString();
                fileRequest.dataInserimento = ds.Tables["VERS"].Rows[0]["DTA_CREAZIONE"].ToString();
                DocsPaDB.Query_DocsPAWS.Utenti u = new DocsPaDB.Query_DocsPAWS.Utenti();
                string full_name_utente          = u.getUtenteById(infoUtente.idPeople).descrizione;
                if (full_name_utente != null)
                {
                    fileRequest.autore = full_name_utente;
                }

                //EMosca 29/11/2004

                /*Aggiunto && oldApp!="" nell'if.
                 * oldApp risulta vuoto per tutte le versioni
                 * (tranne Hummingbird che inserisce di default un pdf di size=0 alla creazione del doc.)
                 */
                if (update && oldApp != "")
                {
                    DocsPaDB.Query_DocsPAWS.Documenti documenti = new DocsPaDB.Query_DocsPAWS.Documenti();
                    documenti.UpdateApplication(oldApp, fileRequest.docNumber);
                }

                DocsPaDB.Query_DocsPAWS.Documenti documenti2 = new DocsPaDB.Query_DocsPAWS.Documenti();
                documenti2.UpdateVersionManager(fileRequest, daInviare);

                logger.Debug("Fine addVersion");
            }
            catch (Exception exception)
            {
                logger.Debug("Errore durante l'aggiunta di una versione.", exception);

                if (update)
                {
                    DocsPaDB.Query_DocsPAWS.Documenti documenti = new DocsPaDB.Query_DocsPAWS.Documenti();
                    documenti.UpdateApplication(oldApp, fileRequest.docNumber);
                }

                result = false;
            }

            return(result);
        }
Example #11
0
        /// <summary>
        /// Per reperire la locazione del documento
        /// </summary>
        /// <param name="schedaDoc"></param>
        /// <param name="objSicurezza"></param>
        /// <param name="isNewDoc"></param>
        /// <returns></returns>
        public static string getDocumentLocation(SchedaDocumento schedaDoc, DocsPaVO.utente.InfoUtente objSicurezza, bool isNewDoc)
        {
            string result = null;

            try
            {
                if (schedaDoc != null)
                {
                    //legge il record da DPA_CORR_GLOBALI in JOIN con DPA_AMMINISTRA
                    DocsPaDB.Query_DocsPAWS.Documentale documentale = new DocsPaDB.Query_DocsPAWS.Documentale();

                    System.Data.DataSet corrispondente;

                    if (!documentale.DOC_GetCorrByIdPeople(objSicurezza.idPeople, out corrispondente))
                    {
                        logger.Debug("Errore nella lettura del corrispondente relativo al documento");
                        throw new Exception();
                    }

                    //legge l'amministrazione
                    string amministrazione = DocsPaUtils.Data.DataReaderHelper.GetValue <string>(corrispondente.Tables[0].Rows[0], "VAR_CODICE_AMM", false);

                    string codiceUO = string.Empty;
                    if (schedaDoc.creatoreDocumento != null && schedaDoc.creatoreDocumento.uo_codiceCorrGlobali != null)
                    {
                        codiceUO = schedaDoc.creatoreDocumento.uo_codiceCorrGlobali;
                    }
                    else
                    {
                        codiceUO = DocsPaServices.DocsPaQueryHelper.getCodiceUO(schedaDoc.docNumber);
                        if ((codiceUO == null || codiceUO.Equals("")) && isNewDoc)
                        {
                            //legge l'id della uo di appartenenza del gruppo
                            string id = documentale.DOC_GetIdUoBySystemId(objSicurezza.idGruppo);

                            if (string.IsNullOrEmpty(id))
                            {
                                logger.Debug("Errore nella lettura del gruppo relativo al documento");
                                throw new Exception();
                            }
                            //recupera il nome della UO
                            codiceUO = documentale.DOC_GetUoById(id);
                        }
                    }

                    //legge la tabella profile
                    System.Data.DataSet documento;
                    if (!documentale.DOC_GetDocByDocNumber(schedaDoc.docNumber, out documento))
                    {
                        logger.Debug("Errore nella lettura del documento: " + schedaDoc.docNumber);
                        throw new Exception();
                    }
                    //legge l'anno di creazione del documento
                    string anno = System.DateTime.Parse(documento.Tables[0].Rows[0]["CREATION_DATE"].ToString()).Year.ToString();
                    //verifica se il documento è protocollato
                    string tipoProtocollo;
                    tipoProtocollo = documento.Tables[0].Rows[0]["CHA_TIPO_PROTO"].ToString().ToUpper();

                    string registro       = "";
                    string arrivoPartenza = "";
                    if (schedaDoc.tipoProto == "A" || schedaDoc.tipoProto == "P" || schedaDoc.tipoProto == "I" || schedaDoc.tipoProto == "R")
                    {
                        //crea il path nel caso di documento protocollato -> AMMINISTRAZIONE + REGISTRO + ANNO + [COD_UO] + [ARRIVO|PARTENZA]

                        //legge il registro della protocollazione
                        //controllo che l'idRegistro esiste
                        string idRegistro = "";
                        if (schedaDoc.registro != null && !String.IsNullOrEmpty(schedaDoc.registro.systemId))
                        {
                            idRegistro = schedaDoc.registro.systemId;
                        }
                        if (String.IsNullOrEmpty(idRegistro))
                        {
                            documento.Tables[0].Rows[0]["ID_REGISTRO"].ToString();
                        }
                        registro = documentale.DOC_GetRegistroById(idRegistro);
                        if (registro == null)
                        {
                            logger.Debug("registro non trovato");
                            registro = "";
                        }

                        if (schedaDoc.tipoProto.Equals("A"))
                        {
                            arrivoPartenza = "Arrivo";
                        }
                        else if (schedaDoc.tipoProto.Equals("P"))
                        {
                            arrivoPartenza = "Partenza";
                        }
                        else if (schedaDoc.tipoProto.Equals("I"))
                        {
                            arrivoPartenza = "Interno";
                        }
                        else if (schedaDoc.tipoProto.Equals("R"))
                        {
                            arrivoPartenza = "StampaRegistro";
                        }
                    }

                    string filePath = OCSConfigurations.GetDocPathPattern();
                    filePath = filePath.Replace("AMMINISTRAZIONE", amministrazione);
                    filePath = filePath.Replace("REGISTRO", registro);
                    filePath = filePath.Replace("ANNO", anno);
                    filePath = filePath.Replace("ARRIVO_PARTENZA", arrivoPartenza);
                    filePath = filePath.Replace("UFFICIO", codiceUO);
                    filePath = filePath.Replace("UTENTE", objSicurezza.userId);

                    filePath = filePath.Replace("//", "/");
                    if (filePath.EndsWith("/"))
                    {
                        filePath = filePath.Remove(filePath.Length - 1, 1);
                    }

                    //verifica se la directory esiste
                    string pathCompleto = OCSConfigurations.GetDocRootFolder() + "/" + filePath;
                    pathCompleto = pathCompleto.Replace("//", "/");

                    //restituisce la directory
                    result = pathCompleto;
                }
            }
            catch (Exception e)
            {
                logger.Error("Errore creazione path documentale per documento: " + schedaDoc.docNumber, e);
                result = null;
            }
            return(result);
        }
Example #12
0
        /// <summary>
        /// Copia visibilità da ruolo a ruolo
        /// </summary>
        /// <param name="idGroup"></param>
        /// <param name="idPeople"></param>
        /// <returns></returns>
        public EsitoOperazione CopyVisibility(DocsPaVO.utente.InfoUtente infoUtente, DocsPaVO.Security.CopyVisibility copyVisibility)
        {
            DocsPaDB.Query_DocsPAWS.Documentale documentaleDB = new DocsPaDB.Query_DocsPAWS.Documentale();
            EsitoOperazione esitoOperazione = new EsitoOperazione();

            using (DocsPaDB.TransactionContext transactionContext = new DocsPaDB.TransactionContext())
            {
                try
                {
                    //L'allineamento della visibilità in DOCUMENTUM non viene fatto chiamando la "ClearAndGrant",
                    //ma i documenti / fascicoli per cui allineare la visibilità vengono inseriti in una tabella di appoggio "DPA_OBJECTS_SYNC_PENDING"
                    //Documenti
                    documentaleDB.insertInObjectsSyncPending(copyVisibility, DocsPaDB.Query_DocsPAWS.Documentale.objTypeCopyVisiblity.DOCUMENTI);

                    //Fascicoli
                    documentaleDB.insertInObjectsSyncPending(copyVisibility, DocsPaDB.Query_DocsPAWS.Documentale.objTypeCopyVisiblity.FASCICOLI);

                    /* -- CODICE COMMENTATO PERCHE' L'ALLINEAMENTO CON DOCUMENTUM NON VIENE FATTO COME DI SEGUITO CHIAMANDO LA "ClearAndGrant"
                     * -- MA I DOCUMENTI / FASCICOLI PER CUI SINCRONIZZARE LA VISIBILITA' VENGONO INSERITI IN UN TABELLA DI APPOGGIO "DPA_OBJECTS_SYNC_PENDING"
                     * //Documenti
                     * System.Data.DataSet dsDocumenti = documentaleDB.getIdDocOrFascCopyVis(copyVisibility, DocsPaDB.Query_DocsPAWS.Documentale.objTypeCopyVisiblity.DOCUMENTI);
                     *
                     * logger.Debug("Inizio impostazione ACL documenti per copia visibilità - Documentum");
                     * for (int i = 0; i < dsDocumenti.Tables[0].Rows.Count; i++)
                     * {
                     *  string docNumber = dsDocumenti.Tables[0].Rows[i]["THING"].ToString();
                     *
                     *  DocsPaDocumentale_DOCUMENTUM.DctmServices.Custom.AclDefinition aclData = null;
                     *  aclData = Dfs4DocsPa.getAclDefinition(docNumber, DocsPaObjectTypes.ObjectTypes.DOCUMENTO, this.InfoUtente);
                     *  DocsPaDocumentale_DOCUMENTUM.DctmServices.Custom.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance<DocsPaDocumentale_DOCUMENTUM.DctmServices.Custom.IAclService>(UserManager.ImpersonateSuperUser());
                     *
                     *  //Usato per evitare il blocco dell'intero processo eventualmente un solo documento ha problemi nell'allineamento delle ACL
                     *  try
                     *  {
                     *      aclService.ClearAndGrant(aclData);
                     *  }
                     *  catch (Exception ex)
                     *  {
                     *      logger.Debug("Errore nell'allineamento delle ACL Documentum per il documento DOCNUMBER : " + docNumber + " - metodo: CopyVisibility - ", ex);
                     *  }
                     * }
                     * logger.Debug("Fine impostazione ACL documenti per copia visibilità - Documentum");
                     *
                     * //Fascicoli
                     * System.Data.DataSet dsFascicoli = documentaleDB.getIdDocOrFascCopyVis(copyVisibility, DocsPaDB.Query_DocsPAWS.Documentale.objTypeCopyVisiblity.FASCICOLI);
                     *
                     * logger.Debug("Inizio impostazione ACL fascicoli per copia visibilità - Documentum");
                     * for (int i = 0; i < dsFascicoli.Tables[0].Rows.Count; i++)
                     * {
                     *  string idProject = dsFascicoli.Tables[0].Rows[i]["THING"].ToString();
                     *
                     *  DocsPaDocumentale_DOCUMENTUM.DctmServices.Custom.AclDefinition aclData = null;
                     *  aclData = Dfs4DocsPa.getAclDefinition(idProject, DocsPaObjectTypes.ObjectTypes.FASCICOLO, this.InfoUtente);
                     *  DocsPaDocumentale_DOCUMENTUM.DctmServices.Custom.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance<DocsPaDocumentale_DOCUMENTUM.DctmServices.Custom.IAclService>(UserManager.ImpersonateSuperUser());
                     *
                     *  //Usato per evitare il blocco dell'intero processo eventualmente un solo fascicolo ha problemi nell'allineamento delle ACL
                     *  try
                     *  {
                     *      aclService.ClearAndGrant(aclData);
                     *  }
                     *  catch (Exception ex)
                     *  {
                     *      logger.Debug("Errore nell'allineamento delle ACL Documentum per il fascicolo IDPROJECT : " + idProject + "- metodo: CopyVisibility - ", ex);
                     *  }
                     * }
                     * logger.Debug("Fine impostazione ACL fascicoli per copia visibilità - Documentum");
                     */

                    transactionContext.Complete();
                    esitoOperazione.Codice      = 0;
                    esitoOperazione.Descrizione = "Operazione avvenuta con successo.";
                    return(esitoOperazione);
                }
                catch (Exception e)
                {
                    logger.Error("Errore in OrganigrammaManager  - metodo: CopyVisibility", e);
                    esitoOperazione.Codice      = -1;
                    esitoOperazione.Descrizione = "Problemi durante la copia della visibilità DOCUMENTUM. Consultare il file di log.";
                    return(esitoOperazione);
                }
            }
        }