Example #1
0
        /*
         *   Creates a set of sample objects to be used by get operation tests
         * */
        public void CreateDemoObjects()
        {
            DataPackage dataPackage = new DataPackage();

            String[] keywords = new String[] { "lions", "tigers", "bears" };
            dataPackage.AddDataObject(BuildTestDoc(gifImageObjectName, "upwind", "Sail upwind", keywords, gifImageFilePath));
            dataPackage.AddDataObject(BuildTestDoc(gifImage1ObjectName, "downwind", "Sail downwind", keywords, gifImage1FilePath));
            try
            {
                CreateTestPaths(serviceDemo.DefaultRepository);
                String toRepositoryName = serviceDemo.SecondaryRepository;
                if (serviceDemo.DefaultRepository != null &&
                    serviceDemo.DefaultRepository != serviceDemo.DefaultRepository)
                {
                    CreateTestPaths(serviceDemo.SecondaryRepository);
                    Console.WriteLine("Created test paths on second repository " + serviceDemo.DefaultRepository);
                }
                OperationOptions operationOptions = null;
                sampleData = objectService.Create(dataPackage, operationOptions);
            }
            catch (FaultException <SerializableException> ex)
            {
                Console.WriteLine(String.Format("Got FaultException[{0}] with message: {1}\n", ex.Detail, ex.Message));
            }
            catch (Exception exx)
            {
                Console.WriteLine(exx.StackTrace);
            }
        }
        public void ShowDataPackage()
        {
            DataObject dataObject = new DataObject(new ObjectIdentity("myRepository"));
            DataPackage dataPackage = new DataPackage(dataObject);

            DataObject dataObject1 = new DataObject(new ObjectIdentity("myRepository"));
            dataPackage.AddDataObject(dataObject1);

            foreach (DataObject dataObject2 in dataPackage.DataObjects)
            {
                Console.WriteLine("Data Object: " + dataObject2);
            }
        }
        public void ShowDataPackage()
        {
            DataObject  dataObject  = new DataObject(new ObjectIdentity("myRepository"));
            DataPackage dataPackage = new DataPackage(dataObject);

            DataObject dataObject1 = new DataObject(new ObjectIdentity("myRepository"));

            dataPackage.AddDataObject(dataObject1);

            foreach (DataObject dataObject2 in dataPackage.DataObjects)
            {
                Console.WriteLine("Data Object: " + dataObject2);
            }
        }
Example #4
0
        public DataPackage CreateFolderAndLinkedDoc()
        {
            // create a folder data object
            String      folderName              = "a-test-folder-" + System.DateTime.Now.Ticks;
            DataObject  folderDataObj           = new DataObject(new ObjectIdentity(DefaultRepository), "dm_folder");
            PropertySet folderDataObjProperties = new PropertySet();

            folderDataObjProperties.Set("object_name", folderName);
            folderDataObj.Properties = folderDataObjProperties;

            // create a contentless document DataObject
            String      doc1Name   = "a-test-doc-" + System.DateTime.Now.Ticks;
            DataObject  docDataObj = new DataObject(new ObjectIdentity(DefaultRepository), "dm_document");
            PropertySet properties = new PropertySet();

            properties.Set("object_name", doc1Name);
            docDataObj.Properties = properties;

            // add the folder as a parent of the folder
            ObjectRelationship objRelationship = new ObjectRelationship();

            objRelationship.Target     = folderDataObj;
            objRelationship.Name       = Relationship.RELATIONSHIP_FOLDER;
            objRelationship.TargetRole = Relationship.ROLE_PARENT;
            docDataObj.Relationships.Add(new ObjectRelationship(objRelationship));

            // set up the relationship filter to return the doc and folder
            RelationshipProfile relationProfile = new RelationshipProfile();

            relationProfile.ResultDataMode   = ResultDataMode.REFERENCE;
            relationProfile.TargetRoleFilter = TargetRoleFilter.ANY;
            relationProfile.NameFilter       = RelationshipNameFilter.ANY;
            relationProfile.DepthFilter      = DepthFilter.SPECIFIED;
            relationProfile.Depth            = 2;
            OperationOptions operationOptions = new OperationOptions();

            operationOptions.RelationshipProfile = relationProfile;

            // create the folder and linked document
            DataPackage dataPackage = new DataPackage();

            dataPackage.AddDataObject(docDataObj);
            return(objectService.Create(dataPackage, operationOptions));
        }
Example #5
0
        /// <summary>
        /// Inserimento di una nuova amministrazione nel documentale
        ///
        /// Problema delle DFS:
        /// come da documentazione, inizialmente gli inserimenti venivano effettuati
        /// tutti in un'unica operazione. Il problema è che le cartelle DNC e StampaRegistro
        /// venivano create nel folder HomeCabinet (oltre che normalmente nel cabinet dell'amministrazione).
        /// Ciò sicuramente è dovuto al fatto di inserire tutto in un'unica richiesta.
        /// Per ovviare a questo inconveniente, si è scelto di inserire le cartelle in 2 fasi:
        /// 1. inserimento cabinet 2. inserimento cartelle sottostanti
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public EsitoOperazione Insert(InfoAmministrazione info)
        {
            EsitoOperazione retValue = new EsitoOperazione();

            // ACL per l'amministrazione
            CustomServices.AclDefinition aclDefinition = null;

            // Identity del cabinet dell'amministrazione
            ObjectIdentity cabinetIdentity = null;

            // Identity del gruppo di sistema associato all'amministrazione
            ObjectIdentity groupIdentity = null;

            // Identity del gruppo di sistema che contiene gli amministratori dell'amministrazione
            ObjectIdentity adminGroupIdentity = null;

            try
            {
                // Creazione del cabinet per l'amministrazione
                ObjectPath cabinetPath = this.GetCabinetPath(info);
                logger.Debug("cabinetPath " + cabinetPath);
                cabinetIdentity = this.GetObjectServiceInstance().CreatePath(cabinetPath, DctmConfigurations.GetRepositoryName());

                // Creazione documenti
                ObjectIdentity documentiIdentity   = new ObjectIdentity(DctmConfigurations.GetRepositoryName());
                DataObject     dataObjectDocumenti = new DataObject(documentiIdentity, "dm_folder");
                dataObjectDocumenti.Properties.Set <string>("object_name", DocsPaAdminCabinet.FOLDER_DOCUMENTI);
                dataObjectDocumenti.Relationships.Add(new ReferenceRelationship(cabinetIdentity, Relationship.RELATIONSHIP_FOLDER, Relationship.ROLE_PARENT));

                // Creazione folder titolario
                ObjectIdentity titolarioIdentity   = new ObjectIdentity(DctmConfigurations.GetRepositoryName());
                DataObject     dataObjectTitolario = new DataObject(titolarioIdentity, "dm_folder");
                dataObjectTitolario.Properties.Set <string>("object_name", DocsPaAdminCabinet.FOLDER_TITOLARIO);
                dataObjectTitolario.Relationships.Add(new ReferenceRelationship(cabinetIdentity, Relationship.RELATIONSHIP_FOLDER, Relationship.ROLE_PARENT));

                // Creazione del gruppo di sistema associato all'amministrazione
                groupIdentity = new ObjectIdentity(DctmConfigurations.GetRepositoryName());
                DataObject groupData = new DataObject(groupIdentity, ObjectTypes.GRUPPO);
                groupData.Properties.Set <string>("group_name", TypeGruppo.GetGroupNameForAmministrazione(info.Codice));
                groupData.Properties.Set <string>("description", "Gruppo di sistema: tutti gli utenti dell'amministrazione " + info.Codice);
                groupData.Properties.Set <string>("group_class", "group");

                // Creazione del gruppo di sistema che contiene gli amministratori dell'amministrazione
                //adminGroupIdentity = new ObjectIdentity(DctmConfigurations.GetRepositoryName().ToLower());  //<- PERCHE' TO LOWER!? (Vecchio 6.0)
                adminGroupIdentity = new ObjectIdentity(DctmConfigurations.GetRepositoryName());
                DataObject adminGroupData = new DataObject(adminGroupIdentity, ObjectTypes.GRUPPO);
                adminGroupData.Properties.Set <string>("group_name", TypeGruppo.GetGroupNameForSysAdminAmministrazione(info.Codice));
                adminGroupData.Properties.Set <string>("description", "Gruppo di sistema: sysadmin dell'amministrazione " + info.Codice);
                adminGroupData.Properties.Set <string>("group_class", "group");

                DataPackage dataPackage = new DataPackage();
                dataPackage.AddDataObject(dataObjectDocumenti);
                dataPackage.AddDataObject(dataObjectTitolario);
                dataPackage.AddDataObject(groupData);
                dataPackage.AddDataObject(adminGroupData);

                dataPackage = this.GetObjectServiceInstance().Create(dataPackage, null);

                if (dataPackage.DataObjects.Count == 0)
                {
                    throw new ApplicationException("Nessun oggetto creato");
                }
                else
                {
                    dataObjectDocumenti = dataPackage.DataObjects[0];
                    dataObjectTitolario = dataPackage.DataObjects[1];
                    groupIdentity       = dataPackage.DataObjects[2].Identity;
                    adminGroupIdentity  = dataPackage.DataObjects[3].Identity;

                    // Creazione AclDefinition per tutti gli oggetti dell'amministrazione
                    aclDefinition = this.CreateAclAdmin(info);

                    // Associazione dell'ACL appena creata con gli oggetti dell'amministrazione
                    AclHelper.setAclObjectProperties(dataObjectDocumenti.Properties, aclDefinition);
                    AclHelper.setAclObjectProperties(dataObjectTitolario.Properties, aclDefinition);

                    dataPackage = new DataPackage();
                    dataPackage.AddDataObject(dataObjectDocumenti);
                    dataPackage.AddDataObject(dataObjectTitolario);
                    dataPackage = this.GetObjectServiceInstance().Update(dataPackage, null);

                    logger.Debug(string.Format("Documentum.InsertAmministrazione: {0} oggetti creati per nuova amministrazione {1}, CabinetPath {2}", dataPackage.DataObjects.Count.ToString(), info.Codice, cabinetPath.Path));
                }
            }
            catch (Exception ex)
            {
                // In caso di errore, viene annullata la procedura
                // rimuovendo gli oggetti finora inseriti
                if (aclDefinition != null)
                {
                    try
                    {
                        // Rimozione ACL appena inserita
                        this.DeleteAclAdmin(aclDefinition);
                    }
                    catch (Exception exInner)
                    {
                        logger.Debug(string.Format("Documentum.InsertAmministrazione: errore in rimozione acl '{0}'", aclDefinition.name));
                    }
                }

                // Inserimento nell'identityset degli oggetti da rimuovere
                ObjectIdentitySet createdObjects = new ObjectIdentitySet();

                if (cabinetIdentity != null && cabinetIdentity.ValueType == ObjectIdentityType.OBJECT_ID)
                {
                    createdObjects.AddIdentity(cabinetIdentity);
                }

                if (groupIdentity != null && groupIdentity.ValueType == ObjectIdentityType.OBJECT_ID)
                {
                    createdObjects.AddIdentity(groupIdentity);
                }

                if (adminGroupIdentity != null && adminGroupIdentity.ValueType == ObjectIdentityType.OBJECT_ID)
                {
                    createdObjects.AddIdentity(adminGroupIdentity);
                }

                if (createdObjects.Identities.Count > 0)
                {
                    OperationOptions opts = new OperationOptions();
                    opts.DeleteProfile = this.CreateDeleteProfile();

                    try
                    {
                        // Rimozione di tutti gli oggetti creati per l'amministrazione
                        this.GetObjectServiceInstance().Delete(createdObjects, opts);
                    }
                    catch (Exception exInner)
                    {
                        logger.Debug(string.Format("Documentum.InsertAmministrazione: errore in rimozione cabinet amministrazione '{0}'", info.Codice));
                    }
                }

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

                retValue.Codice      = -1;
                retValue.Descrizione = string.Format("Errore nella creazione del cabinet {0} in Documentum", info.Codice);
            }

            return(retValue);
        }
        public DataPackage CreateFolderAndLinkedDoc()
        {
            // create a folder data object
            String folderName = "a-test-folder-" + System.DateTime.Now.Ticks;
            DataObject folderDataObj = new DataObject(new ObjectIdentity(DefaultRepository), "dm_folder");
            PropertySet folderDataObjProperties = new PropertySet();
            folderDataObjProperties.Set("object_name", folderName);
            folderDataObj.Properties = folderDataObjProperties;

            // create a contentless document DataObject
            String doc1Name = "a-test-doc-" + System.DateTime.Now.Ticks;
            DataObject docDataObj = new DataObject(new ObjectIdentity(DefaultRepository), "dm_document");
            PropertySet properties = new PropertySet();
            properties.Set("object_name", doc1Name);
            docDataObj.Properties = properties;

            // add the folder as a parent of the folder
            ObjectRelationship objRelationship = new ObjectRelationship();
            objRelationship.Target = folderDataObj;
            objRelationship.Name = Relationship.RELATIONSHIP_FOLDER;
            objRelationship.TargetRole = Relationship.ROLE_PARENT;
            docDataObj.Relationships.Add(new ObjectRelationship(objRelationship));

            // set up the relationship filter to return the doc and folder
            RelationshipProfile relationProfile = new RelationshipProfile();
            relationProfile.ResultDataMode = ResultDataMode.REFERENCE;
            relationProfile.TargetRoleFilter = TargetRoleFilter.ANY;
            relationProfile.NameFilter = RelationshipNameFilter.ANY;
            relationProfile.DepthFilter = DepthFilter.SPECIFIED;
            relationProfile.Depth = 2;
            OperationOptions operationOptions = new OperationOptions();
            operationOptions.RelationshipProfile = relationProfile;

            // create the folder and linked document
            DataPackage dataPackage = new DataPackage();
            dataPackage.AddDataObject(docDataObj);
            return objectService.Create(dataPackage, operationOptions);
        }
 /*
  *   Creates a set of sample objects to be used by get operation tests
  * */
 public void CreateDemoObjects()
 {
     DataPackage dataPackage = new DataPackage();
     String[] keywords = new String[] { "lions", "tigers", "bears" };
     dataPackage.AddDataObject(BuildTestDoc(gifImageObjectName, "upwind", "Sail upwind", keywords, gifImageFilePath));
     dataPackage.AddDataObject(BuildTestDoc(gifImage1ObjectName, "downwind", "Sail downwind", keywords, gifImage1FilePath));
     try
     {
         CreateTestPaths(serviceDemo.DefaultRepository);
         String toRepositoryName = serviceDemo.SecondaryRepository;
         if (serviceDemo.DefaultRepository != null
             && serviceDemo.DefaultRepository != serviceDemo.DefaultRepository)
         {
             CreateTestPaths(serviceDemo.SecondaryRepository);
             Console.WriteLine("Created test paths on second repository " + serviceDemo.DefaultRepository);
         }
         OperationOptions operationOptions = null;
         sampleData = objectService.Create(dataPackage, operationOptions);
     }
     catch (FaultException<SerializableException> ex)
     {
         Console.WriteLine(String.Format("Got FaultException[{0}] with message: {1}\n", ex.Detail, ex.Message));
     }
     catch (Exception exx)
     {
         Console.WriteLine(exx.StackTrace);
     }
 }