/// <summary>
/// Prints all the files in the current Folder and any sub Folders.
/// </summary>
/// <param name="parentFolder">The folder we want to print.</param>
/// <param name="connection">The manager object for making Vault Server calls.</param>
private void PrintFilesInFolder(VDF.Vault.Currency.Entities.Folder parentFolder, VDF.Vault.Currency.Connections.Connection connection)
{
// get all the Files in the current Folder.
File[] childFiles = connection.WebServiceManager.DocumentService.GetLatestFilesByFolderId(parentFolder.Id, false);
// print out any Files we find.
if (childFiles != null && childFiles.Any())
{
foreach (File file in childFiles)
{
// print the full path, which is Folder name + File name.
this.m_listBox.Items.Add(parentFolder.FullName + "/" + file.Name);
}
}
// check for any sub Folders.
IEnumerable <VDF.Vault.Currency.Entities.Folder> folders = connection.FolderManager.GetChildFolders(parentFolder, false, false);
if (folders != null && folders.Any())
{
foreach (VDF.Vault.Currency.Entities.Folder folder in folders)
{
// recursively print the files in each sub-Folder
PrintFilesInFolder(folder, connection);
}
}
}
private List <VDF.Vault.Currency.Entities.IEntity> DoFileSearch(SrchCond[] conditions)
{
string bookmark = string.Empty;
SrchStatus status = null;
//search for files
List <VDF.Vault.Currency.Entities.IEntity> retVal = new List <VDF.Vault.Currency.Entities.IEntity>();
while (status == null || retVal.Count < status.TotalHits)
{
FileFolder[] filefolders = m_conn.WebServiceManager.DocumentService.FindFileFoldersBySearchConditions(
conditions, null, null, true, true,
ref bookmark, out status);
if (filefolders != null)
{
foreach (FileFolder fileFolder in filefolders)
{
VDF.Vault.Currency.Entities.Folder folder =
new VDF.Vault.Currency.Entities.Folder(m_conn, fileFolder.Folder);
VDF.Vault.Currency.Entities.FileIteration file =
new VDF.Vault.Currency.Entities.FileIteration(
m_conn, folder, fileFolder.File);
retVal.Add(file);
}
}
}
return(retVal);
}
/// <summary>
/// This function lists all the files in the Vault and displays them in the form's ListBox.
/// </summary>
public void ListAllFiles()
{
// For demonstration purposes, the information is hard-coded.
VDF.Vault.Results.LogInResult results = VDF.Vault.Library.ConnectionManager.LogIn(
"localhost", "Vault", "Administrator", "", VDF.Vault.Currency.Connections.AuthenticationFlags.Standard, null
);
if (!results.Success)
{
return;
}
VDF.Vault.Currency.Connections.Connection connection = results.Connection;
try
{
// Start at the root Folder.
VDF.Vault.Currency.Entities.Folder root = connection.FolderManager.RootFolder;
this.m_listBox.Items.Clear();
// Call a function which prints all files in a Folder and sub-Folders.
PrintFilesInFolder(root, connection);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error");
return;
}
VDF.Vault.Library.ConnectionManager.LogOut(connection);
}
public VaultBrowser(Vault.Currency.Connections.Connection conn, Vault.Currency.Entities.Folder startingFolder, string fileTypeFilterText, string fileTypeFilterCmd)
{
InitializeComponent();
m_conn = conn;
m_currentFolder = startingFolder;
fileName_multiPartTextBox.EditMode = Framework.Forms.Controls.MultiPartTextBoxControl.EditModeOption.ReadOnly;
//create some filetype filters, borrowing from the Select Entity dialog
Forms.Settings.SelectEntitySettings.EntityRegularExpressionFilter filter1 = new Forms.Settings.SelectEntitySettings.EntityRegularExpressionFilter("All Files (*.*)", ".+", Vault.Currency.Entities.EntityClassIds.Files);
fileType_comboBox.Items.Add(filter1);
/*
* Forms.Settings.SelectEntitySettings.EntityRegularExpressionFilter filter2 = new Forms.Settings.SelectEntitySettings.EntityRegularExpressionFilter("Text Files (*.txt)", ".+txt", Vault.Currency.Entities.EntityClassIds.Files);
* fileType_comboBox.Items.Add(filter2);
* Forms.Settings.SelectEntitySettings.EntityRegularExpressionFilter filter3 = new Forms.Settings.SelectEntitySettings.EntityRegularExpressionFilter("Pictures (*.jpg, *.png, *.gif)", ".+jpg|.+png|.+gif", Vault.Currency.Entities.EntityClassIds.Files);
* fileType_comboBox.Items.Add(filter3);
* Forms.Settings.SelectEntitySettings.EntityRegularExpressionFilter filter4 = new Forms.Settings.SelectEntitySettings.EntityRegularExpressionFilter("Project Files (*.ipj)", ".+ipj", Vault.Currency.Entities.EntityClassIds.Files);
* fileType_comboBox.Items.Add(filter4);
*/
Forms.Settings.SelectEntitySettings.EntityRegularExpressionFilter filter2 = new Forms.Settings.SelectEntitySettings.EntityRegularExpressionFilter(fileTypeFilterText, fileTypeFilterCmd, Vault.Currency.Entities.EntityClassIds.Files);
fileType_comboBox.Items.Add(filter2);
fileType_comboBox.SelectedItem = filter2;
m_filterCanDisplayEntity = filter2.CanDisplayEntity;
}
private void btnOk_Click(object sender, EventArgs e)
{
Vault.Currency.Entities.FileIteration file = m_model.SelectedContent.FirstOrDefault() as Vault.Currency.Entities.FileIteration;
if (file != null)
{
m_selectedItem = file;
m_currentFolder = new Autodesk.DataManagement.Client.Framework.Vault.Currency.Entities.Folder(m_conn, file.Parent);
}
}
/// <summary>
/// Upload a file to Vault
/// </summary>
/// <param name="filePath">The full path to a local file.</param>
/// <param name="folderId">The ID of the Vault folder where the file will be uploaded.</param>
public static void Execute(string filePath, VDF.Vault.Currency.Entities.Folder parent, VDF.Vault.Currency.Connections.Connection connection)
{
using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
connection.FileManager.AddFile(parent,
Path.GetFileName(filePath), "Added by Vault Browser",
DateTime.Now, null, null,
ACW.FileClassification.None, false, stream);
}
}
/***************************************************************************************/
public static VDF.Vault.Currency.Entities.FileIteration AddNewFile(VDF.Vault.Currency.Connections.Connection connection, string vaultFolderPath, string localFile, AWS.FileAssocParam[] associations)
{
FileInfo file = new FileInfo(localFile);
VDF.Vault.Currency.Entities.Folder vaultFolder = new VDF.Vault.Currency.Entities.Folder(connection, connection.WebServiceManager.DocumentService.GetFolderByPath(vaultFolderPath));
return(connection.FileManager.AddFile(
parent: vaultFolder,
comment: "Adding new file with name: " + file.Name + ".",
associations: associations,
bom: null,
classification: AWS.FileClassification.None,
hidden: false,
localPathWithFileName: new VDF.Currency.FilePathAbsolute(file)
));
}
public static Autodesk.Connectivity.WebServices.File AddOrUpdateFile(
string localPath, string fileName, Folder vaultFolder, Connection conn)
{
string vaultPath = vaultFolder.FullName + "/" + fileName;
Autodesk.Connectivity.WebServices.File[] result = conn.WebServiceManager.DocumentService.FindLatestFilesByPaths(
vaultPath.ToSingleArray());
Autodesk.Connectivity.WebServices.File retVal = null;
if (result == null || result.Length == 0 || result[0].Id < 0)
{
VDF.Vault.Currency.Entities.Folder vdfFolder = new VDF.Vault.Currency.Entities.Folder(
conn, vaultFolder);
// using a stream so that we can set a different file name
using (FileStream stream = new FileStream(localPath, FileMode.Open, FileAccess.Read))
{
VDF.Vault.Currency.Entities.FileIteration newFile = conn.FileManager.AddFile(
vdfFolder, fileName, "Thunderdome deployment",
System.IO.File.GetLastWriteTime(localPath), null, null,
FileClassification.None, false, stream);
retVal = newFile;
}
}
else
{
VDF.Vault.Currency.Entities.FileIteration vdfFile = new VDF.Vault.Currency.Entities.FileIteration(conn, result[0]);
AcquireFilesSettings settings = new AcquireFilesSettings(conn);
settings.AddEntityToAcquire(vdfFile);
settings.DefaultAcquisitionOption = AcquireFilesSettings.AcquisitionOption.Checkout;
AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (results.FileResults.First().Exception != null)
{
throw results.FileResults.First().Exception;
}
vdfFile = results.FileResults.First().File;
vdfFile = conn.FileManager.CheckinFile(vdfFile, "Thunderdome deployment", false,
null, null, false, null, FileClassification.None, false, localPath.ToVDFPath());
retVal = vdfFile;
}
return(retVal);
}
/// <summary>
/// Prepares the app to browse a vault by creating the inital set of columns, creating the browse model, connecting all the controls to it,
/// and navigating to the root of the vault.
/// </summary>
private void initalizeGrid()
{
Vault.Currency.Properties.PropertyDefinitionDictionary propDefs = m_conn.PropertyManager.GetPropertyDefinitions(null, null, Vault.Currency.Properties.PropertyDefinitionFilter.IncludeAll);
Vault.Forms.Controls.VaultBrowserControl.Configuration initialConfig = new Vault.Forms.Controls.VaultBrowserControl.Configuration(m_conn, "VaultAccess", propDefs);
initialConfig.AddInitialColumn(Vault.Currency.Properties.PropertyDefinitionIds.Client.EntityIcon);
initialConfig.AddInitialColumn(Vault.Currency.Properties.PropertyDefinitionIds.Client.VaultStatus);
initialConfig.AddInitialColumn(Vault.Currency.Properties.PropertyDefinitionIds.Server.EntityName);
initialConfig.AddInitialColumn(Vault.Currency.Properties.PropertyDefinitionIds.Server.CheckInDate);
initialConfig.AddInitialColumn(Vault.Currency.Properties.PropertyDefinitionIds.Server.Comment);
initialConfig.AddInitialColumn(Vault.Currency.Properties.PropertyDefinitionIds.Server.ThumbnailSystem);
initialConfig.AddInitialSortCriteria(Vault.Currency.Properties.PropertyDefinitionIds.Server.EntityName, true);
initialConfig.AddInitialQuickListColumn(Vault.Currency.Properties.PropertyDefinitionIds.Client.EntityIcon);
initialConfig.AddInitialQuickListColumn(Vault.Currency.Properties.PropertyDefinitionIds.Client.VaultStatus);
initialConfig.AddInitialQuickListColumn(Vault.Currency.Properties.PropertyDefinitionIds.Server.EntityName);
initialConfig.AddInitialQuickListColumn(Vault.Currency.Properties.PropertyDefinitionIds.Server.CheckInDate);
initialConfig.AddInitialQuickListColumn(Vault.Currency.Properties.PropertyDefinitionIds.Server.Comment);
initialConfig.AddInitialQuickListColumn(Vault.Currency.Properties.PropertyDefinitionIds.Server.ThumbnailSystem);
m_model = new Forms.Models.BrowseVaultNavigationModel(m_conn, true, true);
m_model.ParentChanged += new EventHandler(m_model_ParentChanged);
m_model.SelectedContentChanged += new EventHandler <Forms.Currency.SelectionChangedEventArgs>(m_model_SelectedContentChanged);
vaultBrowserControl1.SetDataSource(initialConfig, m_model);
vaultBrowserControl1.OptionsCustomizations.CanDisplayEntityHandler = canDisplayEntity;
vaultBrowserControl1.OptionsBehavior.MultiSelect = false;
vaultBrowserControl1.OptionsBehavior.AllowOverrideSelections = false;
vaultNavigationPathComboboxControl1.SetDataSource(m_conn, m_model, null);
//Vault.Currency.Entities.IEntity iEntity;
if (m_currentFolder == null)
{
m_currentFolder = m_conn.FolderManager.RootFolder;
}
m_model.Navigate(m_currentFolder, Forms.Currency.NavigationContext.NewContext);
//m_model.Navigate(m_conn.FolderManager.GetFoldersByIds(ids), Forms.Currency.NavigationContext.NewContext);
}
private void m_addFileToolStripMenuItem_Click(object sender, EventArgs e)
{
Vault.Currency.Entities.Folder parent = m_model.Parent as Vault.Currency.Entities.Folder;
if (parent != null)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Multiselect = true;
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
string[] filePaths = openFileDialog.FileNames;
foreach (string filePath in filePaths)
{
AddFileCommand.Execute(filePath, parent, m_conn);
}
m_model.Reload();
}
}
}
private void CreateFolder()
{
FileNameForm form = new FileNameForm();
form.ShowDialog();
if (form.DialogResult != DialogResult.OK)
{
return;
}
try
{
Vault.Currency.Entities.Folder parent = m_model.Parent as Vault.Currency.Entities.Folder;
Vault.Currency.Entities.EntityCategory category = Vault.Currency.Entities.EntityCategory.EmptyCategory;
m_conn.FolderManager.CreateFolder(parent, form.folderName, false, category);
m_model.Reload();
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
void cmd_Execute(object sender, CommandItemEventArgs e)
{
Util.DoAction(delegate
{
Connection conn = e.Context.Application.Connection;
// lookup the server product to see if we are Vault Professional
// remember the value so we don't have to look it up again in this session
if (m_isVaultPro == null)
{
Product[] products = conn.WebServiceManager.InformationService.GetSystemProducts();
m_isVaultPro = products.Any(n => n.ProductName == "Autodesk.Productstream");
}
FinderDialog dialog = new FinderDialog(m_isVaultPro.Value, conn);
DialogResult result = dialog.ShowDialog();
if (result == DialogResult.OK && dialog.GoToLocation)
{
LocationContext location = null;
if (dialog.GoToEntity.EntityClass.ServerId == VDF.Vault.Currency.Entities.EntityClassIds.ChangeOrders)
{
VDF.Vault.Currency.Entities.ChangeOrder co = dialog.GoToEntity as VDF.Vault.Currency.Entities.ChangeOrder;
if (co != null)
{
location = new LocationContext(SelectionTypeId.ChangeOrder, co.Number);
}
}
else if (dialog.GoToEntity.EntityClass.ServerId == VDF.Vault.Currency.Entities.EntityClassIds.CustomObject)
{
VDF.Vault.Currency.Entities.CustomObject custom = dialog.GoToEntity as VDF.Vault.Currency.Entities.CustomObject;
if (custom != null)
{
CustEnt custEnt = custom;
SelectionTypeId selectionType = new SelectionTypeId(custom.Definition.SystemName);
location = new LocationContext(selectionType, custEnt.Num);
}
}
else if (dialog.GoToEntity.EntityClass.ServerId == VDF.Vault.Currency.Entities.EntityClassIds.Files)
{
VDF.Vault.Currency.Entities.FileIteration file = dialog.GoToEntity as VDF.Vault.Currency.Entities.FileIteration;
if (file != null)
{
location = new LocationContext(SelectionTypeId.File, file.Parent.FullName + "/" + file.EntityName);
}
}
else if (dialog.GoToEntity.EntityClass.ServerId == VDF.Vault.Currency.Entities.EntityClassIds.Folder)
{
VDF.Vault.Currency.Entities.Folder folder = dialog.GoToEntity as VDF.Vault.Currency.Entities.Folder;
if (folder != null)
{
location = new LocationContext(SelectionTypeId.Folder, folder.FullName);
}
}
else if (dialog.GoToEntity.EntityClass.ServerId == VDF.Vault.Currency.Entities.EntityClassIds.Items)
{
VDF.Vault.Currency.Entities.ItemRevision item = dialog.GoToEntity as VDF.Vault.Currency.Entities.ItemRevision;
if (item != null)
{
location = new LocationContext(SelectionTypeId.Item, item.ItemNumber);
}
}
if (location != null)
{
e.Context.GoToLocation = location;
}
}
});
}
/***********************************************************************************************************/
/***************** THIS DOES NOT CURRENTLY WORK BUT IT'S CLOSE - CONTINUE DEVELOPMENT HERE *****************/
/***********************************************************************************************************/
public static void publishDwf(VDF.Vault.Currency.Connections.Connection connection, AWS.File file, string localDirectoryPath, FileInfo actualDwfFile)
{
try
{
AWS.FilePathArray[] filePaths = connection.WebServiceManager.DocumentService.GetLatestAssociatedFilePathsByMasterIds(new long[] { file.MasterId },
AWS.FileAssociationTypeEnum.None, false, AWS.FileAssociationTypeEnum.Attachment, true, true, true, false);
connection.WebServiceManager.DocumentService.SetTurnOffWarningForUserGeneratedDesignVisualization(true);
VDF.Vault.Currency.Entities.Folder admcFolder = new VDF.Vault.Currency.Entities.Folder(connection, connection.WebServiceManager.DocumentService.GetFolderById(file.FolderId));
Option <AWS.File> existingDWF = FileOperations.GetFile(connection, admcFolder.FullName + "/" + actualDwfFile.Name);
if (existingDWF.IsSome)
{
List <AWS.FileAssocLite> oldAssociations = new List <Autodesk.Connectivity.WebServices.FileAssocLite>();
AWS.FileAssocArray[] fass = connection.WebServiceManager.DocumentService.GetDesignVisualizationAttachmentsByFileMasterIds(new long[] { file.MasterId });
//if (fass.Length > 0)
// return;
Option <VDF.Vault.Results.AcquireFilesResults> result = CheckOutFile(connection, existingDWF.Get(), localDirectoryPath, oldAssociations);
//string correctPath2 = result.Get().FileResults.First().LocalPath.FullPath;
//actualDwfFile.CopyTo(correctPath2, true);
//FileInfo newestDwfFile = new FileInfo(correctPath2);
//connection.WebServiceManager.DocumentService.DeleteFileFromFolderUnconditional(existingDWF.Get().MasterId, file.FolderId);
//connection.WebServiceManager.DocumentService.file
VDF.Vault.Currency.Entities.FileIteration fIter = CheckInFile(connection, existingDWF.Get(), "updated dwf", oldAssociations, admcFolder.FullName + "/" + actualDwfFile.Name, actualDwfFile);
/*AWS.FileAssocParam fileParam = new AWS.FileAssocParam();
* fileParam.CldFileId = existingDWF.Get().Id;
* fileParam.RefId = null;
* fileParam.Typ = AWS.AssociationType.Attachment;
* connection.WebServiceManager.DocumentService.AddDesignVisualizationFileAttachment(file.Id, fileParam);
*/
//VDF.Vault.Currency.Entities.FileIteration fIter = connection.FileManager.AddFile(admcFolder, newDwfFile.Name, "added dwf", newDwfFile.LastWriteTime, null, null, AWS.FileClassification.DesignVisualization, true, stream);
//actualDwfFile.CopyTo(result.Get().FileResults.First().LocalPath.FullPath, true);
//CheckInFile(connection, existingDWF.Get(), "updated dwf", oldAssociations, admcFolder.FullName + "/" + existingDWF.Get().Name);
//VDF.Vault.Currency.Entities.FileIteration fIter = connection.FileManager.AddFile(admcFolder, newDwfFile.Name, "added dwf", newDwfFile.LastWriteTime, null, null, AWS.FileClassification.DesignVisualization, true, stream);
//AWS.BreakDesignVisualizationLinkCommandList blist = connection.WebServiceManager.DocumentService.GetBreakDesignVisualizationLinkCommandList();
//bool ya = connection.WebServiceManager.DocumentService.GetTurnOffWarningForUserGeneratedDesignVisualization();
//fass[0].FileAssocs[0].CldFile = connection.WebServiceManager.DocumentService.GetFileByVersion(fIter.EntityMasterId, fIter.VersionNumber);
AWS.FileAssocParam fileParam = new AWS.FileAssocParam();
fileParam.CldFileId = fIter.EntityIterationId;
fileParam.RefId = null;
fileParam.Typ = AWS.AssociationType.Attachment;
connection.WebServiceManager.DocumentService.AddDesignVisualizationFileAttachment(file.Id, fileParam);
//CheckInFile(connection, existingDWF.Get(), "updated dwf", oldAssociations, admcFolder.FullName + "/" + newDwfFile.Name);
}
else
{
using (System.IO.FileStream stream = new FileStream(actualDwfFile.FullName, FileMode.Open))
{
VDF.Vault.Currency.Entities.FileIteration fIter = connection.FileManager.AddFile(admcFolder, actualDwfFile.Name, "added dwf", actualDwfFile.LastWriteTime, null, null, AWS.FileClassification.DesignVisualization, true, stream);
AWS.FileAssocParam fileParam = new AWS.FileAssocParam();
fileParam.CldFileId = fIter.EntityIterationId;
fileParam.RefId = null;
fileParam.Typ = AWS.AssociationType.Attachment;
connection.WebServiceManager.DocumentService.AddDesignVisualizationFileAttachment(file.Id, fileParam);
}
}
}
catch
{
//errornstuff
}
//}
}
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();
}
