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);
}
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);
}
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));
}
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);
}
