コード例 #1
0
        /// <summary>
        /// Caricamento dei valori delle properties relative allo stato checkout per il documento
        /// </summary>
        /// <param name="documentNumber"></param>
        /// <param name="isStampaRegistro"></param>
        /// <returns></returns>
        protected virtual PropertySet LoadCheckOutProperties(string documentNumber, bool isStampaRegistro)
        {
            ObjectIdentity identity = null;

            if (isStampaRegistro)
            {
                identity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(documentNumber);
            }
            else
            {
                identity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(documentNumber);
            }

            List <string> filters = new List <string>();

            filters.Add("r_object_id");
            filters.Add("object_name");
            filters.Add("r_lock_owner");
            filters.Add("r_lock_date");
            filters.Add(TypeDocumento.CHECKOUT_LOCAL_FILE_PATH);
            filters.Add(TypeDocumento.CHECKOUT_MACHINE_NAME);

            if (!isStampaRegistro)
            {
                // Caricamento informazioni di checkout specifiche per documenti non di tipo stampa registro
                filters.Add(TypeDocumento.TIPO_PROTOCOLLO);
            }

            IObjectService service    = this.GetServiceInstance <IObjectService>(true);
            DataObject     dataObject = DfsHelper.getAllPropsAndFolders(service, identity, filters, false);

            return(dataObject.Properties);
        }
コード例 #2
0
        /// <summary>
        /// Aggiornamento delle proprietà dell'oggetto "p3_document"
        /// </summary>
        /// <param name="idCheckOut"></param>
        /// <param name="documentNumber"></param>
        /// <param name="machineName"></param>
        /// <param name="documentLocation"></param>
        /// <returns></returns>
        private bool SaveCheckOutDocumentProperties(string idCheckOut, string documentNumber, string documentLocation, string machineName)
        {
            bool retValue = false;

            try
            {
                // Determina se il documento da bloccare è di tipo stampa registro
                bool isStampaRegistro = (DocsPaQueryHelper.isStampaRegistro(documentNumber));

                ObjectIdentity identity = null;

                if (!string.IsNullOrEmpty(idCheckOut))
                {
                    identity = DfsHelper.createObjectIdentityObjId(idCheckOut);
                }
                else
                {
                    if (DocsPaQueryHelper.isStampaRegistro(documentNumber))
                    {
                        identity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(documentNumber);
                    }
                    else
                    {
                        identity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(documentNumber);
                    }
                }

                DataObject dataObject = new DataObject(identity);
                dataObject.Properties = new PropertySet();

                List <Property> propertyList = new List <Property>();
                propertyList.Add(new StringProperty(TypeDocumento.CHECKOUT_LOCAL_FILE_PATH, documentLocation));
                propertyList.Add(new StringProperty(TypeDocumento.CHECKOUT_MACHINE_NAME, machineName));
                dataObject.Properties.Properties.AddRange(propertyList);

                DataPackage dataPackage = new DataPackage(dataObject);
                dataPackage.RepositoryName = dataObject.Identity.RepositoryName;

                IObjectService service = this.GetServiceInstance <IObjectService>(false);
                dataPackage = service.Update(dataPackage, null);

                retValue = (dataPackage.DataObjects.Count > 0);
            }
            catch (Exception ex)
            {
                retValue = false;

                logger.Debug("Errore in Documentum. SaveCheckOutDocumentProperties: " + ex.ToString());
            }

            return(retValue);
        }
コード例 #3
0
        /// <summary>
        /// UndoCheckout di un documento in stato checkout
        /// </summary>
        /// <param name="checkOutStatus"></param>
        /// <param name="library"></param>
        /// <returns></returns>
        public bool UndoCheckOut(DocsPaVO.CheckInOut.CheckOutStatus checkOutStatus)
        {
            bool retValue = false;

            try
            {
                ObjectIdentity identity = null;

                // Reperimento identity del documento da sbloccare
                if (DocsPaQueryHelper.isStampaRegistro(checkOutStatus.DocumentNumber))
                {
                    identity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(checkOutStatus.DocumentNumber);
                }
                else
                {
                    identity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(checkOutStatus.DocumentNumber);
                }

                ObjectIdentitySet identitySet = new ObjectIdentitySet();
                identitySet.Identities.Add(identity);
                // Reperimento degli ObjectIdentity per ciascun allegato del documento
                identitySet.Identities.AddRange(Dfs4DocsPa.getAllegatiDocumentoIdentities(this.GetServiceInstance <IQueryService>(false), checkOutStatus.DocumentNumber));

                IVersionControlService service = this.GetServiceInstance <IVersionControlService>(false);
                service.CancelCheckout(identitySet);

                retValue = true;

                if (retValue)
                {
                    this.ClearCheckOutStatusObject(checkOutStatus);

                    retValue = this.SaveCheckOutDocumentProperties(checkOutStatus);

                    if (retValue)
                    {
                        logger.Debug(string.Format("Documentum.UndoCheckOut: effettuato l'undocheckout del documento con id {0} e docnumber {1}", checkOutStatus.IDDocument, checkOutStatus.DocumentNumber));
                    }
                }
            }
            catch (Exception ex)
            {
                retValue = false;

                logger.Debug("Errore in Documentum.UndoCheckOut: " + ex.ToString());
            }

            return(retValue);
        }
コード例 #4
0
        /// <summary>
        /// Reperimento dei metadati da documentum relativamente allo stato checkedout del documento
        /// </summary>
        /// <param name="documentNumber"></param>
        /// <returns></returns>
        protected virtual CheckoutInfo GetDctmCheckOutInfo(string documentNumber)
        {
            ObjectIdentity identity = null;

            // Reperimento identity del documento da bloccare
            if (DocsPaQueryHelper.isStampaRegistro(documentNumber))
            {
                identity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(documentNumber);
            }
            else
            {
                identity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(documentNumber);
            }

            if (identity.ValueType == ObjectIdentityType.QUALIFICATION)
            {
                logger.Debug(((Qualification)identity.Value).GetValueAsString());
            }

            ObjectIdentitySet identitySet = new ObjectIdentitySet();

            identitySet.Identities.Add(identity);

            //IVersionControlService service = this.GetVersionServiceInstance();
            IVersionControlService service          = this.GetServiceInstance <IVersionControlService>(true);
            List <CheckoutInfo>    checkOutInfoList = service.GetCheckoutInfo(identitySet);

            if (checkOutInfoList != null && checkOutInfoList.Count > 0)
            {
                return(checkOutInfoList[0]);
            }
            else
            {
                return(null);
            }
        }
コード例 #5
0
        /// <summary>
        /// Checkin di un documento in stato checkout
        /// </summary>
        /// <param name="checkOutStatus"></param>
        /// <param name="library"></param>
        /// <returns></returns>
        public bool CheckIn(DocsPaVO.CheckInOut.CheckOutStatus checkOutStatus, byte[] content, string checkInComments)
        {
            bool retValue = false;

            try
            {
                // Creazione di un nuovo DataObject che rappresenta il documento da sbloccare
                DataObject dataObject = new DataObject();
                dataObject.Type = ObjectTypes.DOCUMENTO;

                // Reperimento identity del documento da sbloccare
                if (DocsPaQueryHelper.isStampaRegistro(checkOutStatus.DocumentNumber))
                {
                    dataObject.Identity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(checkOutStatus.DocumentNumber);
                }
                else
                {
                    dataObject.Identity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(checkOutStatus.DocumentNumber);
                }

                List <Property> propertyList = new List <Property>();

                // Impostazione numero versione
                propertyList.Add(new NumberProperty(TypeDocumento.NUMERO_VERSIONE, DocsPaQueryHelper.getDocumentNextVersionId(checkOutStatus.IDDocument)));

                // Rimozione valore proprietà p3_locked_filepath
                propertyList.Add(new StringProperty(TypeDocumento.CHECKOUT_LOCAL_FILE_PATH, string.Empty));

                // Rimozione valore proprietà p3_locked_file_machinename
                propertyList.Add(new StringProperty(TypeDocumento.CHECKOUT_MACHINE_NAME, string.Empty));

                dataObject.Properties = new PropertySet();
                dataObject.Properties.Properties.AddRange(propertyList);

                // Temporaneo, inserimento contentuto file
                OperationOptions opts = new OperationOptions();

                CheckinProfile checkInProfile = new CheckinProfile();
                checkInProfile.MakeCurrent         = true;
                checkInProfile.DeleteLocalFileHint = true;

                opts.Profiles.Add(checkInProfile);

                // Creazione di un nuovo oggetto BinaryContent
                BinaryContent binaryContent = new BinaryContent();
                binaryContent.Value = content;

                string ext = System.IO.Path.GetExtension(checkOutStatus.DocumentLocation);
                if (ext.StartsWith("."))
                {
                    ext = ext.Substring(1);
                }
                string fileFormat = DfsHelper.getDctmFileFormat(this.GetServiceInstance <IQueryService>(false), ext);

                binaryContent.Format = fileFormat;

                dataObject.Contents.Add(binaryContent);

                DataPackage dataPackage = new DataPackage(dataObject);
                dataPackage.RepositoryName = DctmConfigurations.GetRepositoryName();

                IVersionControlService service = this.GetServiceInstance <IVersionControlService>(false);

                VersionStrategy strategy = VersionStrategy.IMPLIED;
                if (!DocsPaQueryHelper.isDocumentAcquisito(checkOutStatus.IDDocument))
                {
                    strategy = VersionStrategy.SAME_VERSION;
                }

                dataPackage = service.Checkin(dataPackage, strategy, false, null, opts);

                retValue = (dataPackage.DataObjects.Count > 0);

                if (retValue)
                {
                    logger.Debug(string.Format("Documentum.CheckIn: effettuato il checkin del documento con id {0} e docnumber {1}", checkOutStatus.IDDocument, checkOutStatus.DocumentNumber));
                }
            }
            catch (Exception ex)
            {
                retValue = false;

                logger.Debug("Errore in Documentum.CheckIn: " + ex.ToString());
            }

            return(retValue);
        }
コード例 #6
0
        /// <summary>
        /// Checkout di un documento
        /// </summary>
        /// <param name="checkOutStatus">Metadati relativi allo stato del documento in checkout</param>
        /// <param name="user"></param>
        /// <param name="library"></param>
        /// <returns></returns>
        public bool CheckOut(string idDocument, string documentNumber, string documentLocation, string machineName, out CheckOutStatus checkOutStatus)
        {
            checkOutStatus = null;

            // Determina se il documento da bloccare è di tipo stampa registro
            bool isStampaRegistro = (DocsPaQueryHelper.isStampaRegistro(documentNumber));

            bool retValue = this.SaveCheckOutDocumentProperties(string.Empty, documentNumber, documentLocation, machineName);

            try
            {
                if (retValue)
                {
                    ObjectIdentity identity = null;

                    // Reperimento identity del documento da bloccare
                    if (isStampaRegistro)
                    {
                        identity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(documentNumber);
                    }
                    else
                    {
                        identity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(documentNumber);
                    }

                    ObjectIdentitySet identitySet = new ObjectIdentitySet();
                    identitySet.Identities.Add(identity);

                    OperationOptions opts = null;

                    if (DocsPaQueryHelper.getCountAllegati(idDocument) > 0)
                    {
                        // Se il documento contiene allegati, è sicuramente un virtual document
                        CheckoutProfile checkOutProfile = new CheckoutProfile();

                        // Ulteriore verifica se il documento è un allegato o un documento principale
                        checkOutProfile.CheckoutOnlyVDMRoot = !DocsPaQueryHelper.isAllegatoProfilato(documentNumber);

                        opts = new OperationOptions();
                        opts.CheckoutProfile = checkOutProfile;
                    }

                    IVersionControlService service     = this.GetServiceInstance <IVersionControlService>(false);
                    DataPackage            dataPackage = service.Checkout(identitySet, opts);

                    // Reperimento ObjectId della versione in checkout
                    ObjectId objectId = (ObjectId)dataPackage.DataObjects[0].Identity.Value;
                    checkOutStatus = this.GetCheckOutStatus(objectId.Id, idDocument, documentNumber);

                    //if (DocsPaQueryHelper.getCountAllegati(idDocument) > 0)
                    //{
                    //    // Workaround per gli allegati
                    //    this.UndoCheckOutAllegati(documentNumber);
                    //}

                    retValue = true;

                    logger.Debug(string.Format("Documentum.CheckOut: effettuato il checkout del documento con id {0} e docnumber {1}", idDocument, documentNumber));
                }
            }
            catch (Exception ex)
            {
                retValue = false;

                logger.Debug("Errore in Documentum.CheckOut: " + ex.ToString());
            }

            return(retValue);
        }
コード例 #7
0
        /// <summary>
        /// Inserimento di un documento in un folder
        /// </summary>
        /// <param name="idProfile"></param>
        /// <param name="idFolder"></param>
        /// <returns></returns>
        public bool AddDocumentInFolder(string idProfile, string idFolder)
        {
            logger.Info("BEGIN");
            bool retValue = false;

            // Reperimento idfolder per il record di tipo "C" in docspa (root folder)
            idFolder = DocsPaQueryHelper.getIdFolderCType(idFolder);

            // Reperimento docNumber da idProfile
            string docNumber = DocsPaQueryHelper.getDocNumber(idProfile);

            //bool stampaRegistro = DocsPaQueryHelper.isStampaRegistro(docNumber);
            bool stampaRegistro = DocsPaQueryHelper.isStampaRegistroRepertorio(docNumber);

            try
            {
                IObjectService objectService = DctmServiceFactory.GetServiceInstance <IObjectService>(UserManager.ImpersonateSuperUser());

                // 1. recuperare il documento con tutti i link a folder attuali

                ObjectIdentity documentIdentity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(docNumber);

                if (stampaRegistro)
                {
                    documentIdentity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(docNumber);
                }

                // 2. Creare il nuovo link al folder di classificazione
                ObjectIdentity folderIdentity = null;

                // Verifica se l'idFolder si riferisce ad un fascicolo o a un sottofascicolo
                if (!DocsPaQueryHelper.isSottofascicolo(idFolder))
                {
                    // Reperimento id del fascicolo dal folder (record tipo "C")
                    string tipoFascicolo;
                    string idFascicolo = DocsPaQueryHelper.getIdFascicoloFromFolder(idFolder, out tipoFascicolo);

                    folderIdentity = Dfs4DocsPa.getFascicoloIdentityBySystemId(idFascicolo);

                    //Effettuo un refresh dei permessi sul fascicolo per allineare le ACL con DOCUMENTUM
                    //Fascicolo fascicolo = DocsPaQueryHelper.getFascicolo(idFascicolo, this.InfoUtente);
                    //if (fascicolo != null)
                    //  RefreshAclFascicolo(fascicolo);
                }
                else
                {
                    folderIdentity = Dfs4DocsPa.getSottofascicoloIdentityById(idFolder);
                }

                ReferenceRelationship addRelationship = DfsHelper.createParentFolderRelationship(folderIdentity);
                //la aggiungeremo alla lista degli update nell'ultimo passo

                // 3. salvare
                DataObject updatedDoc = new DataObject(documentIdentity);
                updatedDoc.Relationships.Add(addRelationship);

                // 4. Allineamento ACL documento:
                //  per coerenza è necessario che, una volta che il documento
                //  viene inserito in un fascicolo, questo diventi visibile anche
                //  a tutti gli utenti che hanno la visibilità solo sul fascicolo e
                //  non sul documento
                this.UpdateAclDocumento(idProfile, docNumber);

                DataPackage dataPackage = new DataPackage(updatedDoc);
                dataPackage = objectService.Update(dataPackage, null);

                retValue = (dataPackage.DataObjects.Count > 0);

                if (retValue)
                {
                    logger.Debug(string.Format("Documentum.AddDocumentInFolder: inserito il documento con docnumber {0} nel folder con id {1}", idProfile, idFolder));
                }
            }
            catch (Exception ex)
            {
                retValue = false;

                logger.Debug(string.Format("Errore in Documentum.AddDocumentInFolder:\n{0}", ex.ToString()));
            }
            logger.Info("END");
            return(retValue);
        }
コード例 #8
0
        /// <summary>
        /// Rimozione di un documento dal fascicolo (in generale, da tutti i folder presenti nel fascicolo)
        /// </summary>
        /// <param name="idProfile"></param>
        /// <param name="folder"></param>
        /// <returns></returns>
        public bool RemoveDocumentFromProject(string idProfile, DocsPaVO.fascicolazione.Folder folder)
        {
            logger.Debug(string.Format("RemoveDocumentFromProject - IdProfile: {0} - IdFolder: {1} - IdFascicolo: {2}", idProfile, folder.systemID, folder.idFascicolo));

            // 1. recuperare tutti link del documento
            // 2. identificare quelli da rimuovere (tutti quelli sotto il folder in input)
            // 3. aggiungere eventualmente il link a documenti non classificati
            //    (se non c'è neanche più un link residuo)

            bool           retValue = false;
            IObjectService objSrvc  = null;

            // Reperimento docNumber da idProfile
            string docNumber = DocsPaQueryHelper.getDocNumber(idProfile);

            bool isStampaRegistro = DocsPaQueryHelper.isStampaRegistroRepertorio(docNumber);

            try
            {
                string repositoryName = DctmConfigurations.GetRepositoryName();
                //objSrvc = this.GetObjectServiceInstance();
                objSrvc = DctmServiceFactory.GetServiceInstance <IObjectService>(UserManager.ImpersonateSuperUser());
                List <Relationship> removeRelationships = new List <Relationship>();

                // 1. recuperare tutti link del documento:
                ObjectIdentity documentIdentity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(docNumber);
                if (isStampaRegistro)
                {
                    documentIdentity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(docNumber);
                }

                logger.Debug("RemoveDocumentFromProject: 1.recuperare tutti link del documento");

                List <string> filters = new List <string>();
                filters.Add("r_object_id");
                DataObject documentData = DfsHelper.getAllPropsAndFolders(objSrvc, documentIdentity, filters, true);

                // 2. identificare quelli da rimuovere (tutti quelli sotto il folder in input):
                if (documentData.Relationships != null && documentData.Relationships.Count > 0)
                {
                    logger.Debug("RemoveDocumentFromProject:  2. identificare quelli da rimuovere (tutti quelli sotto il folder in input)");

                    // 2a. recuperiamo la root del nodo associato a Folder:
                    ObjectIdentity folderIdentity = Dfs4DocsPa.getFascicoloIdentityBySystemId(folder.idFascicolo);

                    if (folderIdentity.ValueType == ObjectIdentityType.QUALIFICATION)
                    {
                        logger.Debug(((Qualification)folderIdentity.Value).GetValueAsString());
                    }

                    filters = new List <string>();
                    filters.Add("r_folder_path");
                    DataObject folderData = DfsHelper.getAllPropsAndFolders(objSrvc, folderIdentity, filters, false);
                    Property   p          = folderData.Properties.Get("r_folder_path");
                    if (p == null)
                    {
                        throw new Exception("Impossibile leggere r_folder_path");
                    }
                    string rootPath = p.GetValueAsString();

                    logger.Debug(string.Format("RemoveDocumentFromProject: RootPath: {0}", rootPath));

                    foreach (ReferenceRelationship r in documentData.Relationships)
                    {
                        // 2b. recuperiamo il path del folder in esame
                        // qui contiamo sul fatto che gli objectIdentity dei folder a cui è linkato vengano istanziati
                        // come OBJECT_ID
                        string targetDctmId = ((ObjectId)r.Target.Value).Id;

                        logger.Error(string.Format("LOG-DEBUG: RemoveDocumentFromProject: targetDctmId: {0}", targetDctmId));

                        ObjectIdentity targetIdentity = new ObjectIdentity(new ObjectId(targetDctmId), repositoryName);
                        DataObject     targetData     = DfsHelper.getAllPropsAndFolders(objSrvc, targetIdentity, filters, false);

                        Property prop = targetData.Properties.Properties.Find(e => e.Name == "r_folder_path");

                        if (prop != null)
                        {
                            string targetPath = targetData.Properties.Get("r_folder_path").GetValueAsString();

                            logger.Debug(string.Format("RemoveDocumentFromProject: targetPath: {0}", targetPath));

                            //se il target è sotto la root allora è da rimuovere
                            if (targetPath.StartsWith(rootPath))
                            {
                                removeRelationships.Add(DfsHelper.createRemoveParentFolder(targetIdentity));
                            }
                        }
                    }
                }

                // 3. committare il tutto
                DataObject updatedDoc = new DataObject(documentIdentity);
                updatedDoc.Relationships = removeRelationships;

                DataPackage dp    = new DataPackage(updatedDoc);
                DataPackage retDp = objSrvc.Update(dp, null);

                logger.Debug("RemoveDocumentFromProject: 3. committare il tutto");

                if (retDp.DataObjects.Count > 0)
                {
                    retValue = true;

                    logger.Debug(string.Format("Documentum.RemoveDocumentFromProject: rimosso documento con docnumber {0} dal fascicolo con id {0}", idProfile, folder.systemID));
                }
            }
            catch (Exception e)
            {
                retValue = false;

                logger.Debug(string.Format("Errore in Documentum.RemoveDocumentFromProject:\n{0}", e.ToString()));
            }

            return(retValue);
        }
コード例 #9
0
        /// <summary>
        /// Rimozione di un documento da un folder
        /// </summary>
        /// <param name="idProfile"></param>
        /// <param name="folder"></param>
        /// <returns></returns>
        public bool RemoveDocumentFromFolder(string idProfile, DocsPaVO.fascicolazione.Folder folder)
        {
            bool retValue = false;

            // Reperimento docNumber da idProfile
            logger.Debug("Reperimento docNumber da idProfile");
            string docNumber = DocsPaQueryHelper.getDocNumber(idProfile);

            bool isStampaRegistro = DocsPaQueryHelper.isStampaRegistroRepertorio(docNumber);

            try
            {
                logger.Debug("getDocumentoIdentityByDocNumber");
                ObjectIdentity documentIdentity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(docNumber);

                if (isStampaRegistro)
                {
                    documentIdentity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(docNumber);
                }

                ObjectIdentity folderIdentity = null;

                // Verifica se l'id è relativo ad un fascicolo o a un sottofascicolo
                logger.Debug("Verifica se l'id è relativo ad un fascicolo o a un sottofascicolo");
                if (!DocsPaQueryHelper.isSottofascicolo(folder.systemID))
                {
                    folderIdentity = Dfs4DocsPa.getFascicoloIdentityBySystemId(folder.idFascicolo);
                }
                else
                {
                    folderIdentity = DctmServices.Dfs4DocsPa.getSottofascicoloIdentityById(folder.systemID);
                }

                logger.Debug("createRemoveParentFolder");
                ReferenceRelationship removeRelationship = DctmServices.DfsHelper.createRemoveParentFolder(folderIdentity);

                logger.Debug("updatedDoc.Relationships");
                DataObject updatedDoc = new DataObject(documentIdentity);
                updatedDoc.Relationships.Add(removeRelationship);

                DataPackage dp = new DataPackage(updatedDoc);

                logger.Debug("update");
                IObjectService objSrvc = DctmServiceFactory.GetServiceInstance <IObjectService>(UserManager.ImpersonateSuperUser());
                DataPackage    retDp   = objSrvc.Update(dp, null);

                retValue = (retDp.DataObjects.Count > 0);

                if (retValue)
                {
                    logger.Debug(string.Format("Documentum.RemoveDocumentFromFolder: rimosso documento con docnumber {0} dal sottofascicolo con id {0}", idProfile, folder.systemID));
                }
            }
            catch (Exception ex)
            {
                retValue = false;

                logger.Debug(string.Format("Errore in Documentum.RemoveDocumentFromFolder:\n{0}", ex.ToString()));
            }

            return(retValue);
        }