Example #1
0
        public static bool updateFolderLifeCycle(VDF.Vault.Currency.Connections.Connection connection, string folderPath, long stateID, string comment)
        {
            bool result;

            try
            {
                Autodesk.Connectivity.WebServices.Folder fld = FolderHelper.gefolderbyfolderPath(connection, folderPath);
                if (fld.LfCyc != null)
                {
                    connection.WebServiceManager.DocumentServiceExtensions.UpdateFolderLifeCycleStates(fld.Id.ToSingleArray(), stateID.ToSingleArray(), (comment));
                    result = true;
                }
                else
                {
                    result = false;
                }
            }
            catch (SystemException ex)
            {
                Debug.Write(ex.ToString());
                //MessageBox.Show(ex.ToString());
                result = false;
            }
            return(result);
        }
        private void UpdatePermission(AWS.Folder folder)
        {
            string qry = string.Format("{0} LIKE '{1}'", Options.PathColumn, Escape(folder.FullName));

            DataRow[] rows = Data.Select(qry);

            if (rows == null)
            {
                return;
            }
            bool updatePermission = false;

            if ((Data.Columns.IndexOf(Options.UserGroupColumn) > -1) && (Data.Columns.IndexOf(Options.ACLReadColumn) > -1) &&
                (Data.Columns.IndexOf(Options.ACLWriteColumn) > -1) && (Data.Columns.IndexOf(Options.ACLDeleteColumn) > -1))
            {
                updatePermission = true;
            }
            if (updatePermission == false)
            {
                return;
            }
            ResetPermission(folder);
            foreach (DataRow row in rows)
            {
                if ((Data.Columns.IndexOf(Options.UserGroupColumn) > -1) && (Data.Columns.IndexOf(Options.ACLReadColumn) > -1) &&
                    (Data.Columns.IndexOf(Options.ACLWriteColumn) > -1) && (Data.Columns.IndexOf(Options.ACLDeleteColumn) > -1))
                {
                    UpdatePermission(folder, row.Field <string>(Options.UserGroupColumn),
                                     row.Field <string>(Options.ACLReadColumn), row.Field <string>(Options.ACLWriteColumn), row.Field <string>(Options.ACLDeleteColumn));
                }
            }
        }
        private void UpdateLifecycleState(AWS.Folder folder)
        {
            string stateName = string.Empty;

            if (FolderStates.TryGetValue(folder.Id, out stateName))
            {
                UpdateLifecycleState(folder, stateName);
            }
        }
 private void ResetPermission(AWS.Folder folder)
 {
     // TODO: for whatever reason resetting permission on root is causing an error 308
     // we skip it for now
     if (folder.ParId == -1)
     {
         return;
     }
     ServiceManager.SecurityService.UpdateSystemACL(folder.Id, null, AWS.PrpgType.None, AWS.SysAclBeh.Override);
 }
Example #5
0
 public static string getPathbyFileID(VDF.Vault.Currency.Connections.Connection connection, long fileID)
 {
     try
     {
         Autodesk.Connectivity.WebServices.File selectedFile = null;
         selectedFile = connection.WebServiceManager.DocumentService.GetLatestFileByMasterId(fileID);
         Autodesk.Connectivity.WebServices.Folder fld = connection.WebServiceManager.DocumentService.GetFolderById(selectedFile.FolderId);
         resultVal = fld.FullName + "/" + selectedFile.Name;
     }
     catch (SystemException ex)
     {
         Debug.Write(ex.ToString());
         //MessageBox.Show(ex.ToString());
     }
     return(resultVal);
 }
Example #6
0
        public static EntLfCyc getEntityLifeCycleStates(VDF.Vault.Currency.Connections.Connection connection, string folderPath)
        {
            try
            {
                Autodesk.Connectivity.WebServices.Folder fld = FolderHelper.gefolderbyfolderPath(connection, folderPath);
                LfCycDef lifeCycleDef = connection.WebServiceManager.LifeCycleService.GetLifeCycleDefinitionsByIds(
                    fld.LfCyc.LfCycDefId.ToSingleArray()).First();

                lifeCycleDict = lifeCycleDef.StateArray.ToDictionary(n => n.DispName);
            }
            catch (SystemException ex)
            {
                Debug.Write(ex.ToString());
                //MessageBox.Show(ex.ToString());
            }
            return(resultELC);
        }
        private void UpdateLifecycleState(AWS.Folder folder, string stateName)
        {
            Log(MessageCategory.Info, "  Setting lifecycle state to '{0}'", stateName);
            AWS.CatCfg[] configurations = ServiceManager.CategoryService.GetCategoryConfigurationsByBehaviorNames("FLDR", true, new string[] { "LifeCycle" });

            if (configurations == null)
            {
                Log(MessageCategory.Warning, "    Unable to obtain lifecycle info");
                return;
            }
            AWS.CatCfg configuration = configurations.FirstOrDefault(c => c.Cat.Id == folder.Cat.CatId);

            if (configuration == null)
            {
                Log(MessageCategory.Warning, "    Unable to obtain lifecycle info");
                return;
            }
            if (configuration.BhvCfgArray == null)
            {
                Log(MessageCategory.Warning, "    Unable to obtain lifecycle info");
                return;
            }
            AWS.BhvCfg behaviorConfiguration = configuration.BhvCfgArray.FirstOrDefault(b => b.Name.Equals("LifeCycle", StringComparison.CurrentCultureIgnoreCase));

            if ((behaviorConfiguration == null) || (behaviorConfiguration.BhvArray == null))
            {
                Log(MessageCategory.Warning, "    Unable to obtain lifecycle info");
                return;
            }
            AWS.Bhv        behavior             = behaviorConfiguration.BhvArray.FirstOrDefault(b => b.AssignTyp == AWS.BehaviorAssignmentType.Default);
            AWS.LfCycDef[] lifecycleDefinitions = ServiceManager.LifeCycleService.GetLifeCycleDefinitionsByIds(new long[] { behavior.Id });

            if (lifecycleDefinitions == null)
            {
                Log(MessageCategory.Warning, "    Unable to obtain lifecycle info");
                return;
            }
            AWS.LfCycState lifecycleState = lifecycleDefinitions[0].StateArray.FirstOrDefault(s => s.DispName.Equals(stateName, StringComparison.CurrentCultureIgnoreCase));

            if (lifecycleState == null)
            {
                Log(MessageCategory.Warning, "    Unable to obtain lifecycle info");
                return;
            }
            ServiceManager.DocumentServiceExtensions.UpdateFolderLifeCycleStates(new long[] { folder.Id }, new long[] { lifecycleState.Id }, string.Empty);
        }
        private AWS.Folder UpdateCategory(AWS.Folder folder, string categoryName)
        {
            if (string.IsNullOrEmpty(categoryName))
            {
                return(folder);
            }
            AWS.Cat category = Categories.FirstOrDefault(c => c.Name.Equals(categoryName, StringComparison.CurrentCultureIgnoreCase));

            if (category == null)
            {
                Log(MessageCategory.Warning, "  Category '{0}' doesn't exist", categoryName);
                return(folder);
            }
            Log(MessageCategory.Info, "  Applying category '{0}'", categoryName);
            ServiceManager.DocumentServiceExtensions.UpdateFolderCategories(new long[] { folder.Id }, new long[] { category.Id });
            return(ServiceManager.DocumentService.GetFolderById(folder.Id));
        }
Example #9
0
 public static EntLfCyc getFolderCurrentlifeCycle(VDF.Vault.Currency.Connections.Connection connection, string folderPath)
 {
     try
     {
         Autodesk.Connectivity.WebServices.Folder fld = FolderHelper.gefolderbyfolderPath(connection, folderPath);
         if (fld.LfCyc != null)
         {
             resultFLC = fld.LfCyc;
         }
         else
         {
             return(null);
         }
     }
     catch (SystemException ex)
     {
         Debug.Write(ex.ToString());
         //MessageBox.Show(ex.ToString());
     }
     return(resultFLC);
 }
        private void UpdateProperties(AWS.Folder folder, DataRow row)
        {
            List <AWS.PropInstParam> propertyValues = new List <AWS.PropInstParam>();

            foreach (DataColumn column in Data.Columns)
            {
                if (IsPropertyColumn(column.ColumnName) == false)
                {
                    continue;
                }
                AWS.PropDefInfo propertyInfo = Properties.FirstOrDefault(p => p.PropDef.DispName.Equals(column.ColumnName, StringComparison.CurrentCultureIgnoreCase));

                if (propertyInfo == null)
                {
                    Log(MessageCategory.Warning, "  Property '{0}' doesn't exist", column.ColumnName);
                    continue;
                }
                object value = GetPropertyValue(propertyInfo.PropDef, row.Field <string>(column));

                if (value == null)
                {
                    continue;
                }
                AWS.PropInstParam propParam = new AWS.PropInstParam();
                propParam.PropDefId = propertyInfo.PropDef.Id;
                propParam.Val       = value;
                propertyValues.Add(propParam);
            }
            if (propertyValues.Count > 0)
            {
                Log(MessageCategory.Info, "  Updating properties");
                ServiceManager.DocumentServiceExtensions.UpdateFolderProperties(new long[] { folder.Id },
                                                                                new AWS.PropInstParamArray[] {
                    new AWS.PropInstParamArray()
                    {
                        Items = propertyValues.ToArray()
                    }
                });
            }
        }
        private void UpdatePermissionsAndLifecycle(AWS.Folder folder)
        {
            AWS.Folder[] subFolders = ServiceManager.DocumentService.GetFoldersByParentId(folder.Id, false);

            if (subFolders != null)
            {
                foreach (AWS.Folder subFolder in subFolders)
                {
                    UpdatePermissionsAndLifecycle(subFolder);
                }
            }
            try
            {
                Log(MessageCategory.Info, "Processing folder '{0}'", folder.FullName);
                UpdatePermission(folder);
                UpdateLifecycleState(folder);
            }
            catch (Exception ex)
            {
                LogError(ex);
            }
        }
        private void ImportFolderAndProperties(DataRow row)
        {
            string path = row.Field <string>(Options.PathColumn);

            Log(MessageCategory.Info, "[{0}/{1}] Processing path '{2}'.", Data.Rows.IndexOf(row) + 1, Data.Rows.Count, path);

            if (String.IsNullOrEmpty(path))
            {
                Log(MessageCategory.Warning, "Path name is null or empty.");
            }
            bool library = false;

            if (Data.Columns.IndexOf(Options.LibraryColumn) > -1)
            {
                string value = row.Field <string>(Options.LibraryColumn);

                if (string.Equals(value, "1"))
                {
                    library = true;
                }
            }
            AWS.Folder folder = VaultUtilities.GetOrCreateFolder(ServiceManager.DocumentService, path, library);

            if (Data.Columns.IndexOf(Options.CategoryColumn) > -1)
            {
                folder = UpdateCategory(folder, row.Field <string>(Options.CategoryColumn));
            }
            UpdateProperties(folder, row);
            if (Data.Columns.IndexOf(Options.StateColumn) > -1)
            {
                string state = row.Field <string>(Options.StateColumn);

                if (string.IsNullOrEmpty(state) == false)
                {
                    FolderStates[folder.Id] = state;
                }
            }
        }
        public static AWS.Folder GetOrCreateFolder(AWS.DocumentService docSvc, string path, bool libraryFolder)
        {
            AWS.Folder result = null;

            if (String.IsNullOrEmpty(path))
            {
                return(result);
            }

            if (path.EndsWith("/"))
            {
                path = path.TrimEnd('/');
            }
            try
            {
                result = docSvc.GetFolderByPath(path);
            }
            catch
            {
            }
            if (result != null)
            {
                return(result);
            }
            // doesn't exist, create new one
            AWS.Folder parent   = null;
            string[]   subPaths = path.Split('/');
            string     path2    = string.Empty;

            foreach (string subPath in subPaths)
            {
                AWS.Folder folder = null;

                if (path2.Length > 0)
                {
                    path2 += "/";
                }
                path2 += subPath;
                if (path2.Equals("$"))
                {
                    folder = docSvc.GetFolderRoot();
                }
                else
                {
                    AWS.Folder[] subFolders = docSvc.GetFoldersByParentId(parent.Id, false);

                    if (subFolders != null)
                    {
                        folder = subFolders.FirstOrDefault(f => f.FullName.Equals(path2, StringComparison.OrdinalIgnoreCase));
                    }
                }
                if (folder == null)
                {
                    if (parent.ParId != -1)
                    {
                        libraryFolder = parent.IsLib;
                    }
                    folder = docSvc.AddFolder(subPath, parent.Id, libraryFolder);
                }
                parent = folder;
            }
            return(parent);
        }
        private void mCreateExport(IJobProcessorServices context, IJob job)
        {
            List <string> mExpFrmts    = new List <string>();
            List <string> mUploadFiles = new List <string>();

            // read target export formats from settings file
            Settings settings = Settings.Load();

            #region validate execution rules

            mTrace.IndentLevel += 1;
            mTrace.WriteLine("Translator Job started...");

            //pick up this job's context
            Connection connection = context.Connection;
            Autodesk.Connectivity.WebServicesTools.WebServiceManager mWsMgr = connection.WebServiceManager;
            long   mEntId    = Convert.ToInt64(job.Params["EntityId"]);
            string mEntClsId = job.Params["EntityClassId"];

            // only run the job for files
            if (mEntClsId != "FILE")
            {
                return;
            }

            // only run the job for ipt and iam file types,
            List <string> mFileExtensions = new List <string> {
                ".ipt", ".iam"
            };
            ACW.File mFile = mWsMgr.DocumentService.GetFileById(mEntId);
            if (!mFileExtensions.Any(n => mFile.Name.Contains(n)))
            {
                return;
            }

            // apply execution filters, e.g., exclude files of classification "substitute" etc.
            List <string> mFileClassific = new List <string> {
                "ConfigurationFactory", "DesignSubstitute"
            };                                                                                             //add "DesignDocumentation" for 3D Exporters only
            if (mFileClassific.Any(n => mFile.FileClass.ToString().Contains(n)))
            {
                return;
            }

            // you may add addtional execution filters, e.g., category name == "Sheet Metal Part"

            if (settings.ExportFomats == null)
            {
                throw new Exception("Settings expect to list at least one export format!");
            }
            if (settings.ExportFomats.Contains(","))
            {
                mExpFrmts = settings.ExportFomats.Split(',').ToList();
            }
            else
            {
                mExpFrmts.Add(settings.ExportFomats);
            }

            //remove SM formats, if source isn't sheet metal
            if (mFile.Cat.CatName != settings.SmCatDispName)
            {
                if (mExpFrmts.Contains("SMDXF"))
                {
                    mExpFrmts.Remove("SMDXF");
                }
                if (mExpFrmts.Contains("SMSAT"))
                {
                    mExpFrmts.Remove("SMSAT");
                }
            }

            mTrace.WriteLine("Job execution rules validated.");

            #endregion validate execution rules

            #region VaultInventorServer IPJ activation
            //establish InventorServer environment including translator addins; differentiate her in case full Inventor.exe is used
            Inventor.InventorServer mInv          = context.InventorObject as InventorServer;
            ApplicationAddIns       mInvSrvAddIns = mInv.ApplicationAddIns;

            //override InventorServer default project settings by your Vault specific ones
            Inventor.DesignProjectManager projectManager;
            Inventor.DesignProject        mSaveProject, mProject;
            String   mIpjPath      = "";
            String   mWfPath       = "";
            String   mIpjLocalPath = "";
            ACW.File mProjFile;
            VDF.Vault.Currency.Entities.FileIteration mIpjFileIter = null;

            //download and activate the Inventor Project file in VaultInventorServer
            mTrace.IndentLevel += 1;
            mTrace.WriteLine("Job tries activating Inventor project file as enforced in Vault behavior configurations.");
            try
            {
                //Download enforced ipj file
                if (mWsMgr.DocumentService.GetEnforceWorkingFolder() && mWsMgr.DocumentService.GetEnforceInventorProjectFile())
                {
                    mIpjPath = mWsMgr.DocumentService.GetInventorProjectFileLocation();
                    mWfPath  = mWsMgr.DocumentService.GetRequiredWorkingFolderLocation();
                }
                else
                {
                    throw new Exception("Job requires both settings enabled: 'Enforce Workingfolder' and 'Enforce Inventor Project'.");
                }

                String[] mIpjFullFileName = mIpjPath.Split(new string[] { "/" }, StringSplitOptions.None);
                String   mIpjFileName     = mIpjFullFileName.LastOrDefault();

                //get the projects file object for download
                ACW.PropDef[] filePropDefs = mWsMgr.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
                ACW.PropDef   mNamePropDef = filePropDefs.Single(n => n.SysName == "ClientFileName");
                ACW.SrchCond  mSrchCond    = new ACW.SrchCond()
                {
                    PropDefId = mNamePropDef.Id,
                    PropTyp   = ACW.PropertySearchType.SingleProperty,
                    SrchOper  = 3, // is equal
                    SrchRule  = ACW.SearchRuleType.Must,
                    SrchTxt   = mIpjFileName
                };
                string          bookmark     = string.Empty;
                ACW.SrchStatus  status       = null;
                List <ACW.File> totalResults = new List <ACW.File>();
                while (status == null || totalResults.Count < status.TotalHits)
                {
                    ACW.File[] results = mWsMgr.DocumentService.FindFilesBySearchConditions(new ACW.SrchCond[] { mSrchCond },
                                                                                            null, null, false, true, ref bookmark, out status);
                    if (results != null)
                    {
                        totalResults.AddRange(results);
                    }
                    else
                    {
                        break;
                    }
                }
                if (totalResults.Count == 1)
                {
                    mProjFile = totalResults[0];
                }
                else
                {
                    throw new Exception("Job execution stopped due to ambigous project file definitions; single project file per Vault expected");
                }

                //define download settings for the project file
                VDF.Vault.Settings.AcquireFilesSettings mDownloadSettings = new VDF.Vault.Settings.AcquireFilesSettings(connection);
                mDownloadSettings.LocalPath = new VDF.Currency.FolderPathAbsolute(mWfPath);
                mIpjFileIter = new VDF.Vault.Currency.Entities.FileIteration(connection, mProjFile);
                mDownloadSettings.AddFileToAcquire(mIpjFileIter, VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download);

                //download project file and get local path
                VDF.Vault.Results.AcquireFilesResults   mDownLoadResult;
                VDF.Vault.Results.FileAcquisitionResult fileAcquisitionResult;
                mDownLoadResult       = connection.FileManager.AcquireFiles(mDownloadSettings);
                fileAcquisitionResult = mDownLoadResult.FileResults.FirstOrDefault();
                mIpjLocalPath         = fileAcquisitionResult.LocalPath.FullPath;

                //activate this Vault's ipj temporarily
                projectManager = mInv.DesignProjectManager;
                mSaveProject   = projectManager.ActiveDesignProject;
                mProject       = projectManager.DesignProjects.AddExisting(mIpjLocalPath);
                mProject.Activate();

                //[Optionally:] get Inventor Design Data settings and download all related files ---------

                mTrace.WriteLine("Job successfully activated Inventor IPJ.");
            }
            catch (Exception ex)
            {
                throw new Exception("Job was not able to activate Inventor project file. - Note: The ipj must not be checked out by another user.", ex.InnerException);
            }
            #endregion VaultInventorServer IPJ activation

            #region download source file(s)
            mTrace.IndentLevel += 1;
            mTrace.WriteLine("Job downloads source file(s) for translation.");
            //download the source file iteration, enforcing overwrite if local files exist
            VDF.Vault.Settings.AcquireFilesSettings   mDownloadSettings2 = new VDF.Vault.Settings.AcquireFilesSettings(connection);
            VDF.Vault.Currency.Entities.FileIteration mFileIteration     = new VDF.Vault.Currency.Entities.FileIteration(connection, mFile);
            mDownloadSettings2.AddFileToAcquire(mFileIteration, VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download);
            mDownloadSettings2.OrganizeFilesRelativeToCommonVaultRoot = true;
            mDownloadSettings2.OptionsRelationshipGathering.FileRelationshipSettings.IncludeChildren        = true;
            mDownloadSettings2.OptionsRelationshipGathering.FileRelationshipSettings.IncludeLibraryContents = true;
            mDownloadSettings2.OptionsRelationshipGathering.FileRelationshipSettings.ReleaseBiased          = true;
            VDF.Vault.Settings.AcquireFilesSettings.AcquireFileResolutionOptions mResOpt = new VDF.Vault.Settings.AcquireFilesSettings.AcquireFileResolutionOptions();
            mResOpt.OverwriteOption           = VDF.Vault.Settings.AcquireFilesSettings.AcquireFileResolutionOptions.OverwriteOptions.ForceOverwriteAll;
            mResOpt.SyncWithRemoteSiteSetting = VDF.Vault.Settings.AcquireFilesSettings.SyncWithRemoteSite.Always;

            //execute download
            VDF.Vault.Results.AcquireFilesResults mDownLoadResult2 = connection.FileManager.AcquireFiles(mDownloadSettings2);
            //pickup result details
            VDF.Vault.Results.FileAcquisitionResult fileAcquisitionResult2 = mDownLoadResult2.FileResults.Where(n => n.File.EntityName == mFileIteration.EntityName).FirstOrDefault();

            if (fileAcquisitionResult2 == null)
            {
                mSaveProject.Activate();
                throw new Exception("Job stopped execution as the source file to translate did not download");
            }
            string mDocPath = fileAcquisitionResult2.LocalPath.FullPath;
            string mExt     = System.IO.Path.GetExtension(mDocPath); //mDocPath.Split('.').Last();
            mTrace.WriteLine("Job successfully downloaded source file(s) for translation.");
            #endregion download source file(s)

            #region VaultInventorServer CAD Export

            mTrace.WriteLine("Job opens source file.");
            Document mDoc = null;
            mDoc = mInv.Documents.Open(mDocPath);

            foreach (string item in mExpFrmts)
            {
                switch (item)
                {
                case ("STP"):
                    //activate STEP Translator environment,
                    try
                    {
                        TranslatorAddIn mStepTrans = mInvSrvAddIns.ItemById["{90AF7F40-0C01-11D5-8E83-0010B541CD80}"] as TranslatorAddIn;
                        if (mStepTrans == null)
                        {
                            //switch temporarily used project file back to original one
                            mSaveProject.Activate();
                            throw new Exception("Job stopped execution, because indicated translator addin is not available.");
                        }
                        TranslationContext mTransContext = mInv.TransientObjects.CreateTranslationContext();
                        NameValueMap       mTransOptions = mInv.TransientObjects.CreateNameValueMap();
                        if (mStepTrans.HasSaveCopyAsOptions[mDoc, mTransContext, mTransOptions] == true)
                        {
                            //open, and translate the source file
                            mTrace.IndentLevel += 1;
                            mTrace.WriteLine("Job opens source file.");
                            mTransOptions.Value["ApplicationProtocolType"] = 3;     //AP 2014, Automotive Design
                            mTransOptions.Value["Description"]             = "Sample-Job Step Translator using VaultInventorServer";
                            mTransContext.Type = IOMechanismEnum.kFileBrowseIOMechanism;
                            //delete local file if exists, as the export wouldn't overwrite
                            if (System.IO.File.Exists(mDocPath.Replace(mExt, ".stp")))
                            {
                                System.IO.File.SetAttributes(mDocPath.Replace(mExt, ".stp"), System.IO.FileAttributes.Normal);
                                System.IO.File.Delete(mDocPath.Replace(mExt, ".stp"));
                            }
                            ;
                            DataMedium mData = mInv.TransientObjects.CreateDataMedium();
                            mData.FileName = mDocPath.Replace(mExt, ".stp");
                            mStepTrans.SaveCopyAs(mDoc, mTransContext, mTransOptions, mData);
                            //collect all export files for later upload
                            mUploadFiles.Add(mDocPath.Replace(mExt, ".stp"));
                            mTrace.WriteLine("STEP Translator created file: " + mUploadFiles.LastOrDefault());
                            mTrace.IndentLevel -= 1;
                        }
                    }
                    catch (Exception ex)
                    {
                        mTrace.WriteLine("STEP Export Failed: " + ex.Message);
                    }
                    break;

                case "JT":
                    //activate JT Translator environment,
                    try
                    {
                        TranslatorAddIn mJtTrans = mInvSrvAddIns.ItemById["{16625A0E-F58C-4488-A969-E7EC4F99CACD}"] as TranslatorAddIn;
                        if (mJtTrans == null)
                        {
                            //switch temporarily used project file back to original one
                            mTrace.WriteLine("JT Translator not found.");
                            break;
                        }
                        TranslationContext mTransContext = mInv.TransientObjects.CreateTranslationContext();
                        NameValueMap       mTransOptions = mInv.TransientObjects.CreateNameValueMap();
                        if (mJtTrans.HasSaveCopyAsOptions[mDoc, mTransContext, mTransOptions] == true)
                        {
                            //open, and translate the source file
                            mTrace.IndentLevel += 1;

                            mTransOptions.Value["Version"] = 102;     //default
                            mTransContext.Type             = IOMechanismEnum.kFileBrowseIOMechanism;
                            //delete local file if exists, as the export wouldn't overwrite
                            if (System.IO.File.Exists(mDocPath.Replace(mExt, ".jt")))
                            {
                                System.IO.File.SetAttributes(mDocPath.Replace(mExt, ".jt"), System.IO.FileAttributes.Normal);
                                System.IO.File.Delete(mDocPath.Replace(mExt, ".jt"));
                            }
                            ;
                            DataMedium mData = mInv.TransientObjects.CreateDataMedium();
                            mData.FileName = mDocPath.Replace(mExt, ".jt");
                            mJtTrans.SaveCopyAs(mDoc, mTransContext, mTransOptions, mData);
                            //collect all export files for later upload
                            mUploadFiles.Add(mDocPath.Replace(mExt, ".jt"));
                            mTrace.WriteLine("JT Translator created file: " + mUploadFiles.LastOrDefault());
                            mTrace.IndentLevel -= 1;
                        }
                    }
                    catch (Exception ex)
                    {
                        mTrace.WriteLine("JT Export Failed: " + ex.Message);
                    }
                    break;

                case "SMDXF":
                    try
                    {
                        TranslatorAddIn mDXFTrans = mInvSrvAddIns.ItemById["{C24E3AC4-122E-11D5-8E91-0010B541CD80}"] as TranslatorAddIn;
                        mDXFTrans.Activate();
                        if (mDXFTrans == null)
                        {
                            mTrace.WriteLine("DXF Translator not found.");
                            break;
                        }

                        if (System.IO.File.Exists(mDocPath.Replace(mExt, ".dxf")))
                        {
                            System.IO.FileInfo fileInfo = new FileInfo(mDocPath.Replace(mExt, ".dxf"));
                            fileInfo.IsReadOnly = false;
                            fileInfo.Delete();
                        }

                        PartDocument mPartDoc = (PartDocument)mDoc;
                        DataIO       mDataIO  = mPartDoc.ComponentDefinition.DataIO;
                        String       mOut     = "FLAT PATTERN DXF?AcadVersion=R12&OuterProfileLayer=Outer";
                        mDataIO.WriteDataToFile(mOut, mDocPath.Replace(mExt, ".dxf"));
                        //collect all export files for later upload
                        mUploadFiles.Add(mDocPath.Replace(mExt, ".dxf"));
                        mTrace.WriteLine("SheetMetal DXF Translator created file: " + mUploadFiles.LastOrDefault());
                        mTrace.IndentLevel -= 1;
                    }
                    catch (Exception ex)
                    {
                        mTrace.WriteLine("SMDXF Export Failed: " + ex.Message);
                    }
                    break;

                default:
                    break;
                }
            }
            mDoc.Close(true);
            mTrace.WriteLine("Source file closed");

            //switch temporarily used project file back to original one
            mSaveProject.Activate();

            mTrace.WriteLine("Job exported file(s); continues uploading.");
            mTrace.IndentLevel -= 1;

            #endregion VaultInventorServer CAD Export

            #region Vault File Management

            foreach (string file in mUploadFiles)
            {
                ACW.File           mExpFile        = null;
                System.IO.FileInfo mExportFileInfo = new System.IO.FileInfo(file);
                if (mExportFileInfo.Exists)
                {
                    //copy file to output location
                    if (settings.OutPutPath != "")
                    {
                        System.IO.FileInfo fileInfo = new FileInfo(settings.OutPutPath + "\\" + mExportFileInfo.Name);
                        if (fileInfo.Exists)
                        {
                            fileInfo.IsReadOnly = false;
                            fileInfo.Delete();
                        }
                        System.IO.File.Copy(mExportFileInfo.FullName, settings.OutPutPath + "\\" + mExportFileInfo.Name, true);
                    }

                    //add resulting export file to Vault if it doesn't exist, otherwise update the existing one

                    ACW.Folder mFolder       = mWsMgr.DocumentService.FindFoldersByIds(new long[] { mFile.FolderId }).FirstOrDefault();
                    string     vaultFilePath = System.IO.Path.Combine(mFolder.FullName, mExportFileInfo.Name).Replace("\\", "/");

                    ACW.File wsFile = mWsMgr.DocumentService.FindLatestFilesByPaths(new string[] { vaultFilePath }).First();
                    VDF.Currency.FilePathAbsolute             vdfPath       = new VDF.Currency.FilePathAbsolute(mExportFileInfo.FullName);
                    VDF.Vault.Currency.Entities.FileIteration vdfFile       = null;
                    VDF.Vault.Currency.Entities.FileIteration addedFile     = null;
                    VDF.Vault.Currency.Entities.FileIteration mUploadedFile = null;
                    if (wsFile == null || wsFile.Id < 0)
                    {
                        // add new file to Vault
                        mTrace.WriteLine("Job adds " + mExportFileInfo.Name + " as new file.");

                        if (mFolder == null || mFolder.Id == -1)
                        {
                            throw new Exception("Vault folder " + mFolder.FullName + " not found");
                        }

                        var folderEntity = new Autodesk.DataManagement.Client.Framework.Vault.Currency.Entities.Folder(connection, mFolder);
                        try
                        {
                            addedFile = connection.FileManager.AddFile(folderEntity, "Created by Job Processor", null, null, ACW.FileClassification.DesignRepresentation, false, vdfPath);
                            mExpFile  = addedFile;
                        }
                        catch (Exception ex)
                        {
                            throw new Exception("Job could not add export file " + vdfPath + "Exception: ", ex);
                        }
                    }
                    else
                    {
                        // checkin new file version
                        mTrace.WriteLine("Job uploads " + mExportFileInfo.Name + " as new file version.");

                        VDF.Vault.Settings.AcquireFilesSettings aqSettings = new VDF.Vault.Settings.AcquireFilesSettings(connection)
                        {
                            DefaultAcquisitionOption = VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Checkout
                        };
                        vdfFile = new VDF.Vault.Currency.Entities.FileIteration(connection, wsFile);
                        aqSettings.AddEntityToAcquire(vdfFile);
                        var results = connection.FileManager.AcquireFiles(aqSettings);
                        try
                        {
                            mUploadedFile = connection.FileManager.CheckinFile(results.FileResults.First().File, "Created by Job Processor", false, null, null, false, null, ACW.FileClassification.DesignRepresentation, false, vdfPath);
                            mExpFile      = mUploadedFile;
                        }
                        catch (Exception ex)
                        {
                            throw new Exception("Job could not update existing export file " + vdfFile + "Exception: ", ex);
                        }
                    }
                }
                else
                {
                    throw new Exception("Job could not find the export result file: " + mDocPath.Replace(mExt, ".stp"));
                }

                mTrace.IndentLevel += 1;

                //update the new file's revision
                try
                {
                    mTrace.WriteLine("Job tries synchronizing " + mExpFile.Name + "'s revision in Vault.");
                    mWsMgr.DocumentServiceExtensions.UpdateFileRevisionNumbers(new long[] { mExpFile.Id }, new string[] { mFile.FileRev.Label }, "Rev Index synchronized by Job Processor");
                }
                catch (Exception)
                {
                    //the job will not stop execution in this sample, if revision labels don't synchronize
                }

                //synchronize source file properties to export file properties for UDPs assigned to both
                try
                {
                    mTrace.WriteLine(mExpFile.Name + ": Job tries synchronizing properties in Vault.");
                    //get the design rep category's user properties
                    ACET.IExplorerUtil mExplUtil = Autodesk.Connectivity.Explorer.ExtensibilityTools.ExplorerLoader.LoadExplorerUtil(
                        connection.Server, connection.Vault, connection.UserID, connection.Ticket);
                    Dictionary <ACW.PropDef, object> mPropDictonary = new Dictionary <ACW.PropDef, object>();

                    //get property definitions filtered to UDPs
                    VDF.Vault.Currency.Properties.PropertyDefinitionDictionary mPropDefDic = connection.PropertyManager.GetPropertyDefinitions(
                        VDF.Vault.Currency.Entities.EntityClassIds.Files, null, VDF.Vault.Currency.Properties.PropertyDefinitionFilter.IncludeUserDefined);

                    VDF.Vault.Currency.Properties.PropertyDefinition mPropDef = new PropertyDefinition();
                    ACW.PropInst[] mSourcePropInsts = mWsMgr.PropertyService.GetProperties("FILE", new long[] { mFile.Id }, new long[] { mPropDef.Id });

                    //get property definitions assigned to Design Representation category
                    ACW.CatCfg  catCfg1       = mWsMgr.CategoryService.GetCategoryConfigurationById(mExpFile.Cat.CatId, new string[] { "UserDefinedProperty" });
                    List <long> mFilePropDefs = new List <long>();
                    foreach (ACW.Bhv bhv in catCfg1.BhvCfgArray.First().BhvArray)
                    {
                        mFilePropDefs.Add(bhv.Id);
                    }

                    //get properties assigned to source file and add definition/value pair to dictionary
                    mSourcePropInsts = mWsMgr.PropertyService.GetProperties("FILE", new long[] { mFile.Id }, mFilePropDefs.ToArray());
                    ACW.PropDef[] propDefs = connection.WebServiceManager.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
                    foreach (ACW.PropInst item in mSourcePropInsts)
                    {
                        mPropDef = connection.PropertyManager.GetPropertyDefinitionById(item.PropDefId);
                        ACW.PropDef propDef = propDefs.SingleOrDefault(n => n.Id == item.PropDefId);
                        mPropDictonary.Add(propDef, item.Val);
                    }

                    //update export file using the property dictionary; note this the IExplorerUtil method bumps file iteration and requires no check out
                    mExplUtil.UpdateFileProperties(mExpFile, mPropDictonary);
                }
                catch (Exception ex)
                {
                    mTrace.WriteLine("Job failed copying properties from source file " + mFile.Name + " to export file: " + mExpFile.Name + " . Exception details: " + ex);
                    //you may uncomment the action below if the job should abort executing due to failures copying property values
                    //throw new Exception("Job failed copying properties from source file " + mFile.Name + " to export file: " + mExpFile.Name + " . Exception details: " + ex.ToString() + " ");
                }

                //align lifecycle states of export to source file's state name
                try
                {
                    mTrace.WriteLine(mExpFile.Name + ": Job tries synchronizing lifecycle state in Vault.");
                    Dictionary <string, long> mTargetStateNames = new Dictionary <string, long>();
                    ACW.LfCycDef mTargetLfcDef = (mWsMgr.LifeCycleService.GetLifeCycleDefinitionsByIds(new long[] { mExpFile.FileLfCyc.LfCycDefId })).FirstOrDefault();
                    foreach (var item in mTargetLfcDef.StateArray)
                    {
                        mTargetStateNames.Add(item.DispName, item.Id);
                    }
                    mTargetStateNames.TryGetValue(mFile.FileLfCyc.LfCycStateName, out long mTargetLfcStateId);
                    mWsMgr.DocumentServiceExtensions.UpdateFileLifeCycleStates(new long[] { mExpFile.MasterId }, new long[] { mTargetLfcStateId }, "Lifecycle state synchronized by Job Processor");
                }
                catch (Exception)
                { }

                //attach export file to source file leveraging design representation attachment type
                try
                {
                    mTrace.WriteLine(mExpFile.Name + ": Job tries to attach to its source in Vault.");
                    ACW.FileAssocParam mAssocParam = new ACW.FileAssocParam();
                    mAssocParam.CldFileId         = mExpFile.Id;
                    mAssocParam.ExpectedVaultPath = mWsMgr.DocumentService.FindFoldersByIds(new long[] { mFile.FolderId }).First().FullName;
                    mAssocParam.RefId             = null;
                    mAssocParam.Source            = null;
                    mAssocParam.Typ = ACW.AssociationType.Attachment;
                    mWsMgr.DocumentService.AddDesignRepresentationFileAttachment(mFile.Id, mAssocParam);
                }
                catch (Exception)
                { }

                mTrace.IndentLevel -= 1;
            }

            #endregion Vault File Management

            mTrace.IndentLevel = 1;
            mTrace.WriteLine("Job finished all steps.");
            mTrace.Flush();
            mTrace.Close();
        }
        private void UpdatePermissionsAndLifecycles()
        {
            AWS.Folder folder = ServiceManager.DocumentService.GetFolderRoot();

            UpdatePermissionsAndLifecycle(folder);
        }
        private void UpdatePermission(AWS.Folder folder, string groupName, string readPermis, string writePermis, string deletePermis)
        {
            if (string.IsNullOrEmpty(groupName))
            {
                return;
            }
            AWS.Group group    = Groups.FirstOrDefault(g => g.Name.Equals(groupName, StringComparison.CurrentCultureIgnoreCase));
            long      usrGrpId = -1;

            if (group != null)
            {
                usrGrpId = group.Id;
            }
            else
            {
                AWS.User user = Users.FirstOrDefault(u => u.Name.Equals(groupName, StringComparison.CurrentCultureIgnoreCase));

                if (user != null)
                {
                    usrGrpId = user.Id;
                }
            }
            if (usrGrpId == -1)
            {
                Log(MessageCategory.Warning, "  Unable to find group or user with given name '{0}'", groupName);
                return;
            }
            AWS.EntsAndACLs entsAndACLs = ServiceManager.SecurityService.GetEntACLsByEntityIds(new long[] { folder.Id });
            List <AWS.ACE>  entries     = new List <AWS.ACE>();
            bool            handled     = false;

            if ((entsAndACLs != null) && (entsAndACLs.EntACLArray != null) && (entsAndACLs.ACLArray != null))
            {
                AWS.EntACL entACL = entsAndACLs.EntACLArray.FirstOrDefault(e => e.EntId == folder.Id);
                if (entACL != null)
                {
                    AWS.ACL acl = entsAndACLs.ACLArray.FirstOrDefault(a => a.Id == entACL.ACLId);

                    if (acl != null && acl.ACEArray != null)
                    {
                        foreach (AWS.ACE ace in acl.ACEArray)
                        {
                            if (ace.UserGrpId == usrGrpId)
                            {
                                List <AWS.AccessPermis> permissions = GetAccessPermissions(readPermis, writePermis, deletePermis);

                                AWS.ACE newAce = new AWS.ACE
                                {
                                    UserGrpId   = usrGrpId,
                                    PermisArray = permissions.ToArray(),
                                };

                                entries.Add(newAce);
                                handled = true;
                            }
                            else
                            {
                                entries.Add(ace);
                            }
                        }
                    }
                }
            }

            if (handled == false)
            {
                List <AWS.AccessPermis> permissions = GetAccessPermissions(readPermis, writePermis, deletePermis);
                AWS.ACE newAce = new AWS.ACE
                {
                    UserGrpId   = usrGrpId,
                    PermisArray = permissions.ToArray(),
                };

                entries.Add(newAce);
            }

            Log(MessageCategory.Info, "  Updating permission for user group '{0}'", groupName);
            ServiceManager.SecurityService.UpdateACL(folder.Id, entries.ToArray(), AWS.PrpgType.None);
        }