/// <summary>
/// Download the file(s) to the local folder.
/// </summary>
private static void downloadFile(VDF.Vault.Currency.Connections.Connection connection, VDF.Vault.Currency.Entities.FileIteration fileIter, string folderPath, string topAssemblyName)
{
VDF.Vault.Settings.AcquireFilesSettings settings =
new VDF.Vault.Settings.AcquireFilesSettings(connection);
settings.AddEntityToAcquire(fileIter);
settings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeChildren = true;
settings.OptionsRelationshipGathering.FileRelationshipSettings.RecurseChildren = true;
settings.LocalPath = new VDF.Currency.FolderPathAbsolute(folderPath);
settings.DefaultAcquisitionOption =
VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download;
VDF.Vault.Results.AcquireFilesResults myAcqFilesResults =
connection.FileManager.AcquireFiles(settings);
fileList = new List <string>();
foreach (VDF.Vault.Results.FileAcquisitionResult myFileAcquistionResult in myAcqFilesResults.FileResults)
{
if (myFileAcquistionResult.File.EntityName == topAssemblyName)
{
fileList.Insert(0, myFileAcquistionResult.LocalPath.FullPath);
continue;
}
fileList.Add(myFileAcquistionResult.LocalPath.FullPath);
}
}
/// <summary>
/// Download Vault file using full file path, e.g. "$/Designs/Base.ipt".
/// Preset Options: Download Children (recursively) = Enabled, Enforce Overwrite = True
/// </summary>
/// <param name="conn">Current Vault Connection</param>
/// <param name="VaultFullFileName">FullFilePath</param>
/// <returns>Local path/filename</returns>
public string mGetFileByFullFileName(VDF.Vault.Currency.Connections.Connection conn, string VaultFullFileName)
{
List <string> mFiles = new List <string>();
mFiles.Add(VaultFullFileName);
AWS.File[] wsFiles = conn.WebServiceManager.DocumentService.FindLatestFilesByPaths(mFiles.ToArray());
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFiles[0]));
VDF.Vault.Settings.AcquireFilesSettings settings = new VDF.Vault.Settings.AcquireFilesSettings(conn);
settings.DefaultAcquisitionOption = VCF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download;
settings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeChildren = true;
settings.OptionsRelationshipGathering.FileRelationshipSettings.RecurseChildren = true;
settings.OptionsRelationshipGathering.FileRelationshipSettings.VersionGatheringOption = VDF.Vault.Currency.VersionGatheringOption.Latest;
settings.OptionsRelationshipGathering.IncludeLinksSettings.IncludeLinks = false;
VCF.Vault.Settings.AcquireFilesSettings.AcquireFileResolutionOptions mResOpt = new VCF.Vault.Settings.AcquireFilesSettings.AcquireFileResolutionOptions();
mResOpt.OverwriteOption = VCF.Vault.Settings.AcquireFilesSettings.AcquireFileResolutionOptions.OverwriteOptions.ForceOverwriteAll;
mResOpt.SyncWithRemoteSiteSetting = VCF.Vault.Settings.AcquireFilesSettings.SyncWithRemoteSite.Always;
settings.AddFileToAcquire(mFileIt, VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download);
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (results != null)
{
VDF.Vault.Results.FileAcquisitionResult mFilesDownloaded = results.FileResults.Last();
return(mFilesDownloaded.LocalPath.FullPath.ToString());
}
return("FileNotFound");
}
private static void downloadFile(VDF.Vault.Currency.Connections.Connection connection, VDF.Vault.Currency.Entities.FileIteration file, string folderPath)
{
VDF.Vault.Settings.AcquireFilesSettings settings = new VDF.Vault.Settings.AcquireFilesSettings(connection);
settings.AddEntityToAcquire(file);
settings.LocalPath = new VDF.Currency.FolderPathAbsolute(folderPath);
connection.FileManager.AcquireFiles(settings);
}
private void get()
{
// FilestoreService filestoreService = m_conn.WebServiceManager.FilestoreService;
// DocumentService documentService = m_conn.WebServiceManager.DocumentService;
// Vault.Currency.Entities.IEntity selectedItem = m_model.SelectedContent.FirstOrDefault();
// // download ticket
// long fileId = selectedItem.EntityIterationId;
// ByteArray[] downloadTicket = documentService.GetDownloadTicketsByFileIds(new long[] { fileId });
// byte[] downloadTicketByte = downloadTicket[0].Bytes;
// long firstByte =0;
// long lastByte = 52418559;
//filestoreService.DownloadFilePart(downloadTicketByte, firstByte, lastByte, true);
Vault.Settings.AcquireFilesSettings setting = new Vault.Settings.AcquireFilesSettings(m_conn, true);
long selectedItemId = m_model.SelectedContent.FirstOrDefault().EntityIterationId;
Vault.Currency.Entities.FileIteration selectedItem = m_conn.FileManager.GetFilesByIterationIds(new long[] { selectedItemId }).FirstOrDefault().Value;
setting.AddFileToAcquire(selectedItem, Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download);
m_conn.FileManager.AcquireFiles(setting);
}
private void get()
{
Vault.Settings.AcquireFilesSettings setting = new Vault.Settings.AcquireFilesSettings(m_conn, true);
long selectedItemId = m_model.SelectedContent.FirstOrDefault().EntityIterationId;
Vault.Currency.Entities.FileIteration selectedItem = m_conn.FileManager.GetFilesByIterationIds(new long[] { selectedItemId }).FirstOrDefault().Value;
setting.AddFileToAcquire(selectedItem, Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download);
m_conn.FileManager.AcquireFiles(setting);
}
// prints each sheet of the idw(fileIter) to it's own pdf file.
// if there's more than one sheet referencing the same assembly, they will be combined in one multi-page pdf
// this is not at all tested yet....
private Boolean PrintPDF(VDF.Vault.Currency.Entities.FileIteration fileIter, VDF.Vault.Currency.Connections.Connection connection, ref string errMessage, ref string logMessage)
{
try
{
if (fileIter.EntityName.EndsWith(".idw")) // only print idws
{
// make sure folder exists for downloading idw into.
logMessage += "Checking Target Directory...";
System.IO.DirectoryInfo targetDir = new System.IO.DirectoryInfo(TargetFolder);
if (!targetDir.Exists)
{
targetDir.Create();
}
logMessage += "OK" + "\r\n";
// download the idw from the vault
logMessage += "Downloading idw from the vault...";
VDF.Vault.Settings.AcquireFilesSettings downloadSettings = new VDF.Vault.Settings.AcquireFilesSettings(connection)
{
LocalPath = new VDF.Currency.FolderPathAbsolute(targetDir.FullName),
};
downloadSettings.AddFileToAcquire(fileIter, VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download);
connection.FileManager.AcquireFiles(downloadSettings);
string fileName = downloadSettings.LocalPath.ToString() + @"\" + fileIter.ToString();
PrintObject printOb = new PrintObject();
string errMsg = "";
string logMsg = "";
if (!printOb.printToPDF(fileName, PDFPath, PDFPrinterName, PS2PDFProgrameName, GSWorkingFolder, ref errMsg, ref logMsg))
{
return(false);
}
else
{
return(true);
}
}
else
{
logMessage += "File is not an idw, nothing to print.";
return(true);
}
}
catch (Exception)
{
errMessage += "Unknown Error in function PrintPDF\r\n";
return(false);
}
}
private void Publish(VDF.Vault.Currency.Entities.FileIteration fileIter, VDF.Vault.Currency.Connections.Connection connection)
{
System.IO.DirectoryInfo targetDir = new System.IO.DirectoryInfo(TargetFolder);
if (!targetDir.Exists)
{
targetDir.Create();
}
VDF.Vault.Settings.AcquireFilesSettings downloadSettings = new VDF.Vault.Settings.AcquireFilesSettings(connection)
{
LocalPath = new VDF.Currency.FolderPathAbsolute(targetDir.FullName),
};
downloadSettings.AddFileToAcquire(fileIter, VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download);
connection.FileManager.AcquireFiles(downloadSettings);
}
private VDF.Vault.Settings.AcquireFilesSettings CreateAcquireSettings(bool CheckOut)
{
VDF.Vault.Settings.AcquireFilesSettings settings = new VDF.Vault.Settings.AcquireFilesSettings(mConnection);
if (CheckOut)
{
settings.DefaultAcquisitionOption = VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Checkout;
}
else
{
settings.DefaultAcquisitionOption = VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download;
settings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeChildren = true;
settings.OptionsRelationshipGathering.FileRelationshipSettings.RecurseChildren = true;
settings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeAttachments = true;
settings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeLibraryContents = true;
settings.OptionsRelationshipGathering.FileRelationshipSettings.ReleaseBiased = true;
settings.OptionsRelationshipGathering.FileRelationshipSettings.VersionGatheringOption = VDF.Vault.Currency.VersionGatheringOption.Revision;
settings.OptionsRelationshipGathering.IncludeLinksSettings.IncludeLinks = false;
settings.OptionsResolution.OverwriteOption = VDF.Vault.Settings.AcquireFilesSettings.AcquireFileResolutionOptions.OverwriteOptions.ForceOverwriteAll;
settings.OptionsResolution.SyncWithRemoteSiteSetting = VDF.Vault.Settings.AcquireFilesSettings.SyncWithRemoteSite.Always;
settings.OptionsResolution.UpdateReferencesModel.UpdateVaultStatus = true;
settings.CreateMetaDataFile = true;
}
return(settings);
}
private void GetFiles()
{
topAssemblyName = selectedFile.EntityName;
VDF.Vault.Settings.AcquireFilesSettings acquireFileSettings = new VDF.Vault.Settings.AcquireFilesSettings(vaultConnection);
acquireFileSettings.AddFileToAcquire(selectedFile, acquireFileSettings.DefaultAcquisitionOption);
acquireFileSettings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeChildren = true;
acquireFileSettings.OptionsRelationshipGathering.FileRelationshipSettings.RecurseChildren = true;
acquireFileSettings.DefaultAcquisitionOption = VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download;
FilesResults = vaultConnection.FileManager.AcquireFiles(acquireFileSettings);
foreach (VDF.Vault.Results.FileAcquisitionResult fileResults in FilesResults.FileResults)
{
if (fileResults.File.EntityName == topAssemblyName)
{
if (!InList(fileResults.File.EntityName, referenceDocs))
{
ReferenceDoc newDoc = new ReferenceDoc();
newDoc.PartName = fileResults.File.EntityName;
newDoc.PartPath = fileResults.LocalPath.ToString();
newDoc.DrawingName = System.IO.Path.ChangeExtension(fileResults.File.EntityName, ".idw");
newDoc.DrawingPath = System.IO.Path.ChangeExtension(fileResults.LocalPath.ToString(), ".idw");
newDoc.VaultDrawingPath = newDoc.DrawingPath.Replace("C:\\_Vault_Working_Folder", "$").Replace("\\", "/");
referenceDocs.Add(newDoc);
}
VDF.Currency.FilePathAbsolute filePathAbs = fileResults.LocalPath;
assemblyPath = filePathAbs.ToString();
}
if (IsDoc(fileResults.File.EntityName) && fileResults.File.EntityName != topAssemblyName)
{
if (!InList(fileResults.File.EntityName, referenceDocs))
{
ReferenceDoc newDoc = new ReferenceDoc();
newDoc.PartName = fileResults.File.EntityName;
newDoc.PartPath = fileResults.LocalPath.ToString();
newDoc.DrawingName = System.IO.Path.ChangeExtension(fileResults.File.EntityName, ".idw");
newDoc.DrawingPath = System.IO.Path.ChangeExtension(fileResults.LocalPath.ToString(), ".idw");
newDoc.VaultDrawingPath = newDoc.DrawingPath.Replace("C:\\_Vault_Working_Folder", "$").Replace("\\", "/");
referenceDocs.Add(newDoc);
}
}
}
referenceDocs.Sort((x, y) => x.DrawingName.CompareTo(y.DrawingName));
string[] vaultDrawingFiles = new string[referenceDocs.Count];
int i = 0;
foreach (ReferenceDoc rd in referenceDocs)
{
if (CheckForDups(rd.DrawingName, referenceDocs))
{
vaultDrawingFiles[i] = rd.VaultDrawingPath;
i++;
}
}
drawingFiles = vaultConnection.WebServiceManager.DocumentService.FindLatestFilesByPaths(vaultDrawingFiles);
List <VDF.Vault.Currency.Entities.FileIteration> fileIters = new List <VDF.Vault.Currency.Entities.FileIteration>();
foreach (ACW.File vFile in drawingFiles)
{
if (vFile.Name != null)
{
fileIters.Add(new VDF.Vault.Currency.Entities.FileIteration(vaultConnection, vFile));
}
}
VDF.Vault.Settings.AcquireFilesSettings drawingFileSetting = new VDF.Vault.Settings.AcquireFilesSettings(vaultConnection);
foreach (VDF.Vault.Currency.Entities.FileIteration fi in fileIters)
{
if (fi.EntityName != null)
{
drawingFileSetting.AddFileToAcquire(fi, VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download);
}
}
VDF.Vault.Results.AcquireFilesResults drawingFileResults = vaultConnection.FileManager.AcquireFiles(drawingFileSetting);
foreach (ReferenceDoc rd in referenceDocs)
{
InventorApprentice.ApprenticeServerDocument doc;
doc = apprentice.Open(rd.PartPath);
rd.Revision = GetRevision(doc);
rd.PDFName = System.IO.Path.GetFileNameWithoutExtension(rd.PartName) + "rev--" + rd.Revision + ".pdf";
}
}
// use ERP names instead of file names.
private Boolean PDFfileUpdate(VDF.Vault.Currency.Entities.FileIteration fileIter, VDF.Vault.Currency.Connections.Connection connection, ref string logMessage, ref string errMessage)
{
try
{
// download the file
System.IO.DirectoryInfo targetDir = new System.IO.DirectoryInfo(m_TargetFolder);
if (!targetDir.Exists)
{
targetDir.Create();
}
VDF.Vault.Settings.AcquireFilesSettings downloadSettings = new VDF.Vault.Settings.AcquireFilesSettings(connection)
{
LocalPath = new VDF.Currency.FolderPathAbsolute(targetDir.FullName),
};
downloadSettings.AddFileToAcquire(fileIter, VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download);
VDF.Vault.Results.AcquireFilesResults results =
connection.FileManager.AcquireFiles(downloadSettings);
string fileName = downloadSettings.LocalPath.ToString() + @"\" + fileIter.ToString();
// ipts and iams are easier to deal with than idws
if (fileName.EndsWith(".ipt") || fileName.EndsWith(".iam"))
{
PrintObject printOb = new PrintObject();
if (printOb.deletePDF(fileName, m_PDFPath, ref logMessage, ref errMessage))
{
return(true);
}
else
{
return(false);
}
}
else if (fileName.EndsWith(".idw")) // for idws we have to loop through each drawing sheet
{
try
{
string modelName = "";
// set up lists for storing the actual model names the sheets are referencing
List <string> modelNames = new List <string>();
List <VDF.Vault.Currency.Entities.FileIteration> fIterations = new List <VDF.Vault.Currency.Entities.FileIteration>();
VDF.Vault.Currency.Properties.PropertyDefinitionDictionary propDefs =
new VDF.Vault.Currency.Properties.PropertyDefinitionDictionary();
Inventor.ApprenticeServerComponent oApprentice = new ApprenticeServerComponent();
Inventor.ApprenticeServerDrawingDocument drgDoc;
drgDoc = (Inventor.ApprenticeServerDrawingDocument)oApprentice.Document;
oApprentice.Open(fileName);
drgDoc = (Inventor.ApprenticeServerDrawingDocument)oApprentice.Document;
ACW.PropDef[] filePropDefs =
connection.WebServiceManager.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
ACW.PropDef vaultNamePropDef = filePropDefs.Single(n => n.SysName == "Name");
// for each sheet in the idw, search the vault for the sheet's corresponding ipt or iam
foreach (Sheet sh in drgDoc.Sheets)
{
if (sh.DrawingViews.Count > 0) // I added this line because one pdf with a BOM only sheet
// kept failing. This line fixed the problemf or that file
// but it is definitely not well tested...
{
errMessage += " " + sh.DrawingViews[1].ReferencedDocumentDescriptor.DisplayName + "found";
if (sh.DrawingViews.Count > 0)
{
modelName = sh.DrawingViews[1].ReferencedDocumentDescriptor.DisplayName;
PrintObject printOb = new PrintObject();
if (printOb.deletePDF(modelName, m_PDFPath, ref logMessage, ref errMessage))
{
//logMessage += "Deleted PDF: " + pair.Value.Value.ToString() + "\r\n";
//we already logged a message in the deletePDF function
}
else
{
logMessage += logMessage;
errMessage += "Can not delete PDF Error1 in function FileUpdate\r\n";
return(false);
}
}
}
}
}
catch (Exception ex)
{
logMessage += logMessage;
errMessage += "Can not delete PDF Error2 in function FileUpdate\r\n" + ex.Message + "\r\n";
return(false);
}
}
return(true);
}
catch (Exception)
{
logMessage += logMessage;
errMessage += errMessage;
return(false);
}
}
/// <summary>
/// Find file by 1 to many search criteria as property/value pairs.
/// Downloads the first file matching all search criterias; include many as required to get the unique file.
/// Preset Search Operator Options: [Property] is (exactly) [Value]; multiple conditions link up using AND condition.
/// Preset Download Options: Download Children (recursively) = Enabled, Enforce Overwrite = True
/// </summary>
/// <param name="conn">Current Vault Connection</param>
/// <param name="SearchCriteria">Dictionary of property/value pairs</param>
/// <returns>Local path/filename</returns>
public string mGetFilebySearchCriteria(VDF.Vault.Currency.Connections.Connection conn, Dictionary <string, string> SearchCriteria)
{
AWS.PropDef[] mFilePropDefs = conn.WebServiceManager.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
//iterate mSearchcriteria to get property definitions and build AWS search criteria
List <AWS.SrchCond> mSrchConds = new List <AWS.SrchCond>();
int i = 0;
List <AWS.File> totalResults = new List <AWS.File>();
foreach (var item in SearchCriteria)
{
AWS.PropDef mFilePropDef = mFilePropDefs.Single(n => n.DispName == item.Key);
AWS.SrchCond mSearchCond = new AWS.SrchCond();
{
mSearchCond.PropDefId = mFilePropDef.Id;
mSearchCond.PropTyp = AWS.PropertySearchType.SingleProperty;
mSearchCond.SrchOper = 1; //equals
if (i == 0)
{
mSearchCond.SrchRule = AWS.SearchRuleType.May;
}
else
{
mSearchCond.SrchRule = AWS.SearchRuleType.Must;
}
mSearchCond.SrchTxt = item.Value;
}
mSrchConds.Add(mSearchCond);
i++;
}
string bookmark = string.Empty;
AWS.SrchStatus status = null;
while (status == null || totalResults.Count < status.TotalHits)
{
AWS.File[] mSrchResults = conn.WebServiceManager.DocumentService.FindFilesBySearchConditions(
mSrchConds.ToArray(), null, null, false, true, ref bookmark, out status);
if (mSrchResults != null)
{
totalResults.AddRange(mSrchResults);
}
else
{
break;
}
}
//if results not empty
if (totalResults.Count == 1)
{
AWS.File wsFile = totalResults.First <AWS.File>();
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFile));
VDF.Vault.Settings.AcquireFilesSettings settings = new VDF.Vault.Settings.AcquireFilesSettings(conn);
settings.DefaultAcquisitionOption = VCF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download;
settings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeChildren = true;
settings.OptionsRelationshipGathering.FileRelationshipSettings.RecurseChildren = true;
settings.OptionsRelationshipGathering.FileRelationshipSettings.VersionGatheringOption = VDF.Vault.Currency.VersionGatheringOption.Latest;
settings.OptionsRelationshipGathering.IncludeLinksSettings.IncludeLinks = false;
VCF.Vault.Settings.AcquireFilesSettings.AcquireFileResolutionOptions mResOpt = new VCF.Vault.Settings.AcquireFilesSettings.AcquireFileResolutionOptions();
mResOpt.OverwriteOption = VCF.Vault.Settings.AcquireFilesSettings.AcquireFileResolutionOptions.OverwriteOptions.ForceOverwriteAll;
mResOpt.SyncWithRemoteSiteSetting = VCF.Vault.Settings.AcquireFilesSettings.SyncWithRemoteSite.Always;
settings.AddFileToAcquire(mFileIt, VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download);
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (results != null)
{
VDF.Vault.Results.FileAcquisitionResult mFilesDownloaded = results.FileResults.Last();
return(mFilesDownloaded.LocalPath.FullPath.ToString());
}
else
{
return("FileNotFound");
}
}
else
{
return("FileNotFound");
}
}
private void AddFileEvents_Post(object sender, AddFileCommandEventArgs e)
{
var service = sender as IWebService;
if (service == null)
{
return;
}
var wsm = service.WebServiceManager;
var connection = new VDF.Vault.Currency.Connections.Connection(
wsm,
wsm.WebServiceCredentials.VaultName,
service.SecurityHeader.UserId,
wsm.WebServiceCredentials.ServerIdentities.DataServer,
VDF.Vault.Currency.Connections.AuthenticationFlags.Standard);
var file = e.ReturnValue;
var localFilePath = string.Empty;
var fileExtension = System.IO.Path.GetExtension(file.Name);
if (fileExtension == null ||
!new[] { ".ipt", ".iam", ".ipn", ".idw", ".dwg" }.Contains(fileExtension.ToLower()))
{
return;
}
#region Application detection
var isExplorer = false;
var isCopyDesign = false;
var isInventor = false;
try
{
var entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null && entryAssembly.Location.StartsWith(
@"C:\Program Files\Autodesk\Vault Professional 2018\Explorer\Connectivity.Vault",
StringComparison.OrdinalIgnoreCase))
{
isExplorer = true;
var regex = new Regex(@"Copy of file \'.*\' version \'.*'\. \(.*\)");
var match = regex.Match(file.Comm);
if (match.Success)
{
isCopyDesign = true;
}
}
else if (entryAssembly != null && entryAssembly.Location.Equals(
@"C:\Program Files\Autodesk\Vault Professional 2018\Explorer\CopyDesign.exe",
StringComparison.OrdinalIgnoreCase))
{
isCopyDesign = true;
}
else
{
var callingAssembly = Assembly.GetCallingAssembly();
if (callingAssembly.Location.Equals(
@"C:\Program Files\Autodesk\Inventor 2018\Bin\Autodesk.Connectivity.WebServices.dll",
StringComparison.OrdinalIgnoreCase))
{
isInventor = true;
}
}
}
catch (Exception)
{
isExplorer = false;
}
#endregion
if (isInventor)
{
try
{
#region Download file (VDF)
var fileIteration = new VDF.Vault.Currency.Entities.FileIteration(
connection, file);
var folderPathAbsolute = new VDF.Currency.FolderPathAbsolute(@"C:\temp\");
var acquireSettings = new VDF.Vault.Settings.AcquireFilesSettings(connection)
{
DefaultAcquisitionOption =
VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download,
LocalPath = folderPathAbsolute
};
acquireSettings.AddEntityToAcquire(fileIteration);
var acquireFiles = connection.FileManager.AcquireFiles(acquireSettings);
var fileResult = acquireFiles.FileResults.First();
localFilePath = fileResult.LocalPath.FullPath;
#endregion
#region Download file (WebServiceManager)
//localFilePath = string.Format(@"C:\temp\{0}", file.Name);
//var fileSize = file.FileSize;
//var maxPartSize = wsm.FilestoreService.GetMaximumPartSize();
//var ticket = wsm.DocumentService.GetDownloadTicketsByMasterIds(
// new[] { file.MasterId })[0];
//byte[] bytes;
//using (var stream = new System.IO.MemoryStream())
//{
// var startByte = 0;
// while (startByte < fileSize)
// {
// var endByte = startByte + maxPartSize;
// if (endByte > fileSize)
// endByte = fileSize;
// using (var filePart =
// wsm.FilestoreService.DownloadFilePart(
// ticket.Bytes, startByte, endByte, true))
// {
// byte[] buffer = StreamToByteArray(filePart);
// stream.Write(buffer, 0, buffer.Length);
// startByte += buffer.Length;
// }
// }
// bytes = new byte[stream.Length];
// stream.Seek(0, System.IO.SeekOrigin.Begin);
// stream.Read(bytes, 0, (int)stream.Length);
// stream.Close();
//}
//System.IO.File.WriteAllBytes(localFilePath, bytes);
#endregion
#region Get InternalName and iProperty Class
var documentInfo = Apprentice.GetDocumentInfo(localFilePath);
#endregion
#region Update properties
var propDefs = wsm.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
var propDef = propDefs.SingleOrDefault(p => p.DispName.Equals("Internal ID"));
if (propDef == null)
{
return;
}
var util = Autodesk.Connectivity.Explorer.ExtensibilityTools.ExplorerLoader.LoadExplorerUtil(
wsm.WebServiceCredentials.ServerIdentities.DataServer,
wsm.WebServiceCredentials.VaultName,
service.SecurityHeader.UserId,
service.SecurityHeader.Ticket);
var properties = new Dictionary <PropDef, object> {
{ propDef, documentInfo.InternalName }
};
util.UpdateFileProperties(file, properties);
#endregion
#region Assign file to custom entity 'Class'
if (!string.IsNullOrEmpty(documentInfo.Class))
{
var custEnt = GetClassCustEntByName(wsm, documentInfo.Class);
if (custEnt != null)
{
wsm.DocumentService.AddLink(custEnt.Id, "FILE", file.Id, null);
}
}
#endregion
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
#region Delete local file
if (System.IO.File.Exists(localFilePath))
{
try
{
System.IO.File.Delete(localFilePath);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
#endregion
}
}
if (isExplorer)
{
// file is added by Vault Explorer
}
if (isCopyDesign)
{
// file is added by CopyDesign
}
}
public JobOutcome Execute(IJobProcessorServices context, IJob job)
{
try
{
Inventor.InventorServer mInv = context.InventorObject as InventorServer;
#region validate execution rules
//pick up this job's context
mConnection = context.Connection;
Autodesk.Connectivity.WebServicesTools.WebServiceManager mWsMgr = mConnection.WebServiceManager;
long mEntId = Convert.ToInt64(job.Params["EntityId"]);
string mEntClsId = job.Params["EntityClassId"];
// only run the job for files; handle the scenario, that an item lifecycle transition accidently submitted the job
if (mEntClsId != "FILE")
{
context.Log(null, "This job type is for files only.");
return(JobOutcome.Failure);
}
// only run the job for ipt and iam file types,
List <string> mFileExtensions = new List <string> {
".ipt", ".iam", "idw", "dwg"
};
ACW.File mFile = mWsMgr.DocumentService.GetFileById(mEntId);
if (!mFileExtensions.Any(n => mFile.Name.EndsWith(n)))
{
context.Log(null, "Skipped Job execution as file type did not match iLogic enabled files (ipt, iam, idw/dwg");
return(JobOutcome.Success);
}
//run iLogic for Inventor DWG file types/skip AutoCAD DWG files
ACW.PropDef[] mPropDefs = mWsMgr.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
ACW.PropDef mPropDef = null;
ACW.PropInst mPropInst = null;
if (mFile.Name.EndsWith(".dwg"))
{
mPropDef = mPropDefs.Where(n => n.SysName == "Provider").FirstOrDefault();
mPropInst = (mWsMgr.PropertyService.GetPropertiesByEntityIds("FILE", new long[] { mFile.Id })).Where(n => n.PropDefId == mPropDef.Id).FirstOrDefault();
if (mPropInst.Val.ToString() != "Inventor DWG")
{
context.Log(null, "Skipped Job execution as DWG type did not match Inventor DWG");
return(JobOutcome.Success);
}
}
ApplicationAddIns mInvSrvAddIns = mInv.ApplicationAddIns;
ApplicationAddIn iLogicAddIn = mInvSrvAddIns.ItemById["{3BDD8D79-2179-4B11-8A5A-257B1C0263AC}"];
if (iLogicAddIn != null && iLogicAddIn.Activated != true)
{
iLogicAddIn.Activate();
}
dynamic mAutomation = iLogicAddIn.Automation;
if (mAutomation == null)
{
Trace.WriteLine("iLogic-AddIn automation is not available; exiting job processing");
context.Log(null, "iLogic-AddIn automation is not available");
return(JobOutcome.Failure);
}
#endregion validate execution rules
#region VaultInventorServer IPJ activation
//override InventorServer default project settings by your Vault specific ones
Inventor.DesignProjectManager mInvIpjManager;
Inventor.DesignProject mInvDfltProject, mInvVltProject;
String mIpjPath = "";
String mWfPath = "";
String mIpjLocalPath = "";
ACW.File mIpj;
VDF.Vault.Currency.Entities.FileIteration mIpjFileIter = null;
//validate ipj setting, a single, enforced ipj is expected
if (mWsMgr.DocumentService.GetEnforceWorkingFolder() && mWsMgr.DocumentService.GetEnforceInventorProjectFile())
{
mIpjPath = mWsMgr.DocumentService.GetInventorProjectFileLocation();
mWfPath = mWsMgr.DocumentService.GetRequiredWorkingFolderLocation();
//Set mWfPath to alternate temporary working folder if needed, e.g. to delete all files after job execution
}
else
{
context.Log(null, "Job requires both settings enabled: 'Enforce Workingfolder' and 'Enforce Inventor Project'.");
return(JobOutcome.Failure);
}
//download and activate the Inventor Project file in VaultInventorServer
mIpj = (mWsMgr.DocumentService.FindLatestFilesByPaths(new string[] { mIpjPath })).FirstOrDefault();
try
{
String[] mIpjFullFileName = mIpjPath.Split(new string[] { "/" }, StringSplitOptions.None);
String mIpjFileName = mIpjFullFileName.LastOrDefault();
//define download settings for the project file
VDF.Vault.Settings.AcquireFilesSettings mAcqrIpjSettings = new VDF.Vault.Settings.AcquireFilesSettings(mConnection);
mAcqrIpjSettings.LocalPath = new VDF.Currency.FolderPathAbsolute(mWfPath);
mIpjFileIter = new VDF.Vault.Currency.Entities.FileIteration(mConnection, mIpj);
mAcqrIpjSettings.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 = mConnection.FileManager.AcquireFiles(mAcqrIpjSettings);
fileAcquisitionResult = mDownLoadResult.FileResults.FirstOrDefault();
mIpjLocalPath = fileAcquisitionResult.LocalPath.FullPath;
//activate this Vault's ipj
mInvIpjManager = mInv.DesignProjectManager;
mInvDfltProject = mInvIpjManager.ActiveDesignProject;
mInvVltProject = mInvIpjManager.DesignProjects.AddExisting(mIpjLocalPath);
mInvVltProject.Activate();
//[Optionally:] get Inventor Design Data settings and download all related files ---------
}
catch
{
context.Log(null, "Job was not able to activate Inventor project file. - Note: The ipj must not be checked out by another user.");
return(JobOutcome.Failure);
}
#endregion VaultInventorServer IPJ activation
#region download source file(s)
//build download options including DefaultAcquisitionOptions
VDF.Vault.Currency.Entities.FileIteration mFileIteration = new VDF.Vault.Currency.Entities.FileIteration(mConnection, mFile);
VDF.Vault.Currency.Entities.FileIteration mNewFileIteration = null;
VDF.Vault.Settings.AcquireFilesSettings mAcqrFlsSettings;
VDF.Vault.Results.AcquireFilesResults mAcqrFlsResults2;
VDF.Vault.Results.FileAcquisitionResult mFileAcqsResult2;
string mLocalFileFullName = "", mExt = "";
if (mFileIteration.IsCheckedOut == true && mFileIteration.IsCheckedOutToCurrentUser == false)
{
//exit the job, as the job user is not able to edit the file reserved to another user
mInvDfltProject.Activate();
context.Log(null, "Job stopped execution as the source file to process is checked-out by another user.");
return(JobOutcome.Failure);
}
//download only
if (mFileIteration.IsCheckedOut == true && mFileIteration.IsCheckedOutToCurrentUser == true)
{
mAcqrFlsSettings = CreateAcquireSettings(false);
mAcqrFlsSettings.AddFileToAcquire(mFileIteration, mAcqrFlsSettings.DefaultAcquisitionOption);
mAcqrFlsResults2 = this.mConnection.FileManager.AcquireFiles(mAcqrFlsSettings);
mNewFileIteration = mFileIteration;
mFileAcqsResult2 = mAcqrFlsResults2.FileResults.Where(n => n.File.EntityName == mFileIteration.EntityName).FirstOrDefault();
mLocalFileFullName = mFileAcqsResult2.LocalPath.FullPath;
mExt = System.IO.Path.GetExtension(mLocalFileFullName);
}
//checkout and download
if (mFileIteration.IsCheckedOut == false)
{
try
{
mAcqrFlsSettings = CreateAcquireSettings(true); //checkout (don't checkout related children)
mAcqrFlsSettings.AddFileToAcquire(mFileIteration, mAcqrFlsSettings.DefaultAcquisitionOption);
mAcqrFlsResults2 = this.mConnection.FileManager.AcquireFiles(mAcqrFlsSettings);
mFileAcqsResult2 = mAcqrFlsResults2.FileResults.Where(n => n.File.EntityName == mFileIteration.EntityName).FirstOrDefault();
mNewFileIteration = mFileAcqsResult2.NewFileIteration;
mAcqrFlsSettings = null;
mAcqrFlsSettings = CreateAcquireSettings(false);//download (include related children)
mAcqrFlsSettings.AddFileToAcquire(mNewFileIteration, mAcqrFlsSettings.DefaultAcquisitionOption);
mAcqrFlsResults2 = this.mConnection.FileManager.AcquireFiles(mAcqrFlsSettings);
mLocalFileFullName = mFileAcqsResult2.LocalPath.FullPath;
mExt = System.IO.Path.GetExtension(mLocalFileFullName);
}
catch (Exception)
{
mInvDfltProject.Activate();
context.Log(null, "Job stopped execution as the source file to process did not download or check-out.");
return(JobOutcome.Failure);
}
}
#endregion download source file(s)
#region capture dependencies
//we need to return all relationships during later check-in
List <ACW.FileAssocParam> mFileAssocParams = new List <ACW.FileAssocParam>();
ACW.FileAssocArray mFileAssocArray = mWsMgr.DocumentService.GetLatestFileAssociationsByMasterIds(new long[] { mFile.MasterId },
ACW.FileAssociationTypeEnum.None, false, ACW.FileAssociationTypeEnum.All, false, false, false, true).FirstOrDefault();
if (mFileAssocArray.FileAssocs != null)
{
foreach (ACW.FileAssoc item in mFileAssocArray.FileAssocs)
{
ACW.FileAssocParam mFileAssocParam = new ACW.FileAssocParam();
mFileAssocParam.CldFileId = item.CldFile.Id;
mFileAssocParam.ExpectedVaultPath = item.ExpectedVaultPath;
mFileAssocParam.RefId = item.RefId;
mFileAssocParam.Source = item.Source;
mFileAssocParam.Typ = item.Typ;
mFileAssocParams.Add(mFileAssocParam);
}
}
#endregion capture dependencies
#region iLogic Configuration
//avoid unplanned rule execution triggered by the document itself
mAutomation.RulesOnEventsEnabled = false;
mAutomation.RulesEnabled = false;
//set the iLogic Advanced Configuration Settings
dynamic mFileOptions = mAutomation.FileOptions;
mFileOptions.AddinDirectory = mSettings.iLogicAddinDLLs;
//add the job extension app path and configured external rule directories to the FileOptions.ExternalRuleDirectories for iLogic
List <string> mExtRuleDirs = new List <string>();
mExtRuleDirs.Add(mAppPath);
mExtRuleDirs.AddRange(mSettings.ExternalRuleDirectories.Split(',').ToList <string>());
mFileOptions.ExternalRuleDirectories = mExtRuleDirs.ToArray();
//enable iLogic logging
dynamic mLogCtrl = mAutomation.LogControl;
switch (mSettings.iLogicLogLevel)
{
case "None":
mLogCtrl.Level = 0;
break;
case "Trace":
mLogCtrl.Level = 1;
break;
case "Debug":
mLogCtrl.Level = 2;
break;
case "Info":
mLogCtrl.Level = 3;
break;
case "Warn":
mLogCtrl.Level = 4;
break;
case "Error":
mLogCtrl.Level = 5;
break;
case "Fatal":
mLogCtrl.Level = 6;
break;
default:
mLogCtrl.Level = 5;
break;
}
//enable iLogic to save a log file for each job Id.
string mILogicLogFileFullName = "";
if (mLogCtrl.Level != 0)
{
string mLogName = job.Id + "_" + mFile.Name + "_iLogicSampleJob.log";
System.IO.DirectoryInfo mLogDirInfo = new System.IO.DirectoryInfo(mSettings.iLogicLogDir);
if (mLogDirInfo.Exists == false)
{
mLogDirInfo = System.IO.Directory.CreateDirectory(mSettings.iLogicLogDir);
}
mILogicLogFileFullName = System.IO.Path.Combine(mLogDirInfo.FullName, mLogName);
}
//read rule execution settings
string mVaultRule = mSettings.VaultRuleFullFileName;
string mExtRule = mSettings.ExternalRuleName;
string mExtRuleFullName = null;
string mIntRulesOption = mSettings.InternalRulesOption;
if (mVaultRule != "")
{
ACW.File mRuleFile = mWsMgr.DocumentService.FindLatestFilesByPaths(new string[] { mVaultRule }).FirstOrDefault();
//build download options including DefaultAcquisitionOptions
VDF.Vault.Currency.Entities.FileIteration mRuleFileIter = new VDF.Vault.Currency.Entities.FileIteration(mConnection, mRuleFile);
VDF.Vault.Settings.AcquireFilesSettings mAcqrRuleSettings = CreateAcquireSettings(false);
mAcqrRuleSettings.AddFileToAcquire(mRuleFileIter, mAcqrRuleSettings.DefaultAcquisitionOption);
//download
VDF.Vault.Results.AcquireFilesResults mAcqrRuleResults = this.mConnection.FileManager.AcquireFiles(mAcqrRuleSettings);
//pick-up the new file iteration in case of check-out
VDF.Vault.Results.FileAcquisitionResult mRuleAcqResult = mAcqrRuleResults.FileResults.Where(n => n.File.EntityName == mRuleFileIter.EntityName).FirstOrDefault();
if (mRuleAcqResult.LocalPath != null)
{
mExtRuleFullName = mRuleAcqResult.LocalPath.FullPath;
System.IO.FileInfo fileInfo = new System.IO.FileInfo(mExtRuleFullName);
if (fileInfo.Exists == false)
{
context.Log(null, "Job downloaded rule file but exited due to missing rule file: " + mExtRuleFullName + ".");
mConnection.FileManager.UndoCheckoutFile(mNewFileIteration);
return(JobOutcome.Failure);
}
else
{
mExtRule = fileInfo.Name;
if (!mExtRuleDirs.Any(n => fileInfo.DirectoryName.Equals(n)))
{
context.Log(null, "Job downloaded rule file but exited due to missing iLogic External Rule Directory configuration: Add the path"
+ fileInfo.DirectoryName + " to the list of External Rule Directories.");
mConnection.FileManager.UndoCheckoutFile(mNewFileIteration);
return(JobOutcome.Failure);
}
}
}
else
{
context.Log(null, "Job could not download configured rule file and exited. Compare the 'VaultRuleFullFileName' setting and available rule in Vault.");
return(JobOutcome.Failure);
}
}
#endregion iLogic Configuration
#region Run iLogic Rule(s)
//Open Inventor Document
Document mDoc = mInv.Documents.Open(mLocalFileFullName);
//use case - apply external rule with arguments; additional Vault UDP, status or any information might fill rule arguments
if (mExtRule != "")
{
//required rule arguments to continue Vault interaction within the rule (iLogic-Vault library)
NameValueMap ruleArguments = mInv.TransientObjects.CreateNameValueMap();
ruleArguments.Add("ServerName", mConnection.Server);
ruleArguments.Add("VaultName", mConnection.Vault);
ruleArguments.Add("UserId", mConnection.UserID);
ruleArguments.Add("Ticket", mConnection.Ticket);
//additional rule arguments to build rule conditions evaluating Vault lifecycle information, properties, etc.
if (mSettings.PropagateProps == "True")
{
ACW.PropInst[] mSourcePropInsts = mWsMgr.PropertyService.GetPropertiesByEntityIds("FILE", new long[] { mFileIteration.EntityIterationId });
string mPropDispName;
string mThumbnailDispName = mPropDefs.Where(n => n.SysName == "Thumbnail").FirstOrDefault().DispName;
foreach (ACW.PropInst item in mSourcePropInsts)
{
mPropDispName = mPropDefs.Where(n => n.Id == item.PropDefId).FirstOrDefault().DispName;
//filter thumbnail property, as iLogic RuleArguments will fail reading it.
if (mPropDispName != mThumbnailDispName)
{
ruleArguments.Add(mPropDispName, item.Val);
}
}
}
//call external rule with arguments; return value = 0 in case of successful execution
mRuleSuccess = mAutomation.RunExternalRuleWithArguments(mDoc, mExtRule, ruleArguments);
if (mRuleSuccess != 0)
{
context.Log(null, "Job failed due to failure in external rule: " + mExtRule + ".");
mDoc.Close(true);
mConnection.FileManager.UndoCheckoutFile(mNewFileIteration);
mLogCtrl.SaveLogAs(mILogicLogFileFullName);
return(JobOutcome.Failure);
}
else
{
mAllRulesTextWrp = "External Rule: " + mExtRule;
}
mDoc.Save2(false);
}
//use case - run all, all active or filtered document rules
dynamic mDocRules = mAutomation.Rules(mDoc);
List <dynamic> mRulesToExec = new List <dynamic>();
switch (mSettings.InternalRulesOption)
{
case "None":
break;
case "Active":
if (mDocRules != null)
{
foreach (dynamic rule in mDocRules)
{
if (rule.IsActive == true)
{
mRulesToExec.Add(rule);
}
}
}
break;
case "All":
if (mDocRules != null)
{
foreach (dynamic rule in mDocRules)
{
mRulesToExec.Add(rule);
}
}
break;
default:
foreach (dynamic rule in mDocRules)
{
if (rule.Name.Contains(mSettings.InternalRulesOption))
{
mRulesToExec.Add(rule);
}
}
break;
}
if (mRulesToExec.Count >= 1)
{
foreach (dynamic rule in mRulesToExec)
{
mRuleSuccess = mAutomation.RunRule(mDoc, rule.Name);
if (mRuleSuccess != 0)
{
context.Log(null, "Job failed due to failure in internal rule: " + rule.Name + ".");
mDoc.Close(true);
mConnection.FileManager.UndoCheckoutFile(mNewFileIteration);
mLogCtrl.SaveLogAs(mILogicLogFileFullName);
return(JobOutcome.Failure);
}
else
{
mAllRules.Add(rule.Name);
}
}
}
mDoc.Save2(false);
mDoc.Close(true);
mLogCtrl.SaveLogAs(mILogicLogFileFullName);
if (mAllRules.Count > 0)
{
mAllRulesTextWrp += "\n\r Internal Rule(s):";
foreach (string name in mAllRules)
{
mAllRulesTextWrp += "\r\n " + name;
}
}
#endregion Run iLogic Rules
#region Check-in result
// checkin new file version
VDF.Currency.FilePathAbsolute vdfPath = new VDF.Currency.FilePathAbsolute(mLocalFileFullName);
FileIteration mUploadedFile = null;
try
{
if (mFileAssocParams.Count > 0)
{
mUploadedFile = mConnection.FileManager.CheckinFile(mNewFileIteration, "Created by Custom Job executing iLogic : " + mAllRulesTextWrp,
false, mFileAssocParams.ToArray(), null, true, null, mFileIteration.FileClassification, false, vdfPath);
}
else
{
mUploadedFile = mConnection.FileManager.CheckinFile(mNewFileIteration, "Created by Custom Job executing iLogic : " + mAllRulesTextWrp,
false, null, null, false, null, mFileIteration.FileClassification, false, vdfPath);
}
}
catch
{
context.Log(null, "Job could not check-in updated file: " + mUploadedFile.EntityName + ".");
return(JobOutcome.Failure);
}
#endregion check-in result
#region reset
mInvDfltProject.Activate();
//delete temporary working folder if imlemented here
#endregion reset
return(JobOutcome.Success);
}
catch (Exception ex)
{
context.Log(ex, "Job failed by unhandled exception: " + ex.ToString() + " ");
return(JobOutcome.Failure);
}
}
/*****************************************************************************************/
public static bool SetProperty(VDF.Vault.Currency.Connections.Connection connection, AWS.File file, string propertyName, object value, string tempPath)
{
long userId = connection.UserID;
if (((file.CheckedOut) && (userId != file.CkOutUserId)) || (file.Locked))
{
return(false);
}
Option <AWS.PropDef> definition = PropertyOperations.GetPropertyDefinition(connection, propertyName);
if (definition.IsNone)
{
return(false);
}
VDF.Vault.Currency.Entities.FileIteration fileIteration = new VDF.Vault.Currency.Entities.FileIteration(connection, file);
Option <List <AWS.FileAssocLite> > oldAssociations = FileOperations.GetFileChildrenAssocsLite(connection, fileIteration);
if (oldAssociations.IsNone)
{
return(false);
}
AWS.FileAssocArray[] files = connection.WebServiceManager.DocumentService.GetLatestFileAssociationsByMasterIds(new long[] { file.MasterId }, AWS.FileAssociationTypeEnum.None, false, AWS.FileAssociationTypeEnum.Dependency, true, true, true, true);
bool childCheckedOutByOther = false;
foreach (AWS.FileAssocArray tempFiles in files)
{
try
{
foreach (AWS.FileAssoc tempFile in tempFiles.FileAssocs)
{
if ((tempFile.CldFile.CheckedOut) && (tempFile.CldFile.CkOutUserId == userId))
{
VDF.Vault.Currency.Entities.FileIteration tempIteration = new VDF.Vault.Currency.Entities.FileIteration(connection, tempFile.CldFile);
connection.FileManager.UndoCheckoutFile(tempIteration);
}
else if ((tempFile.CldFile.CheckedOut))
{
childCheckedOutByOther = true;
}
}
}
catch { }
}
if (childCheckedOutByOther)
{
return(false);
}
VDF.Vault.Settings.AcquireFilesSettings acquireFilesSettings = new VDF.Vault.Settings.AcquireFilesSettings(connection, true);
acquireFilesSettings.OptionsResolution.OverwriteOption = VDF.Vault.Settings.AcquireFilesSettings.AcquireFileResolutionOptions.OverwriteOptions.ForceOverwriteAll;
acquireFilesSettings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeAttachments = false;
acquireFilesSettings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeChildren = false; // true?
acquireFilesSettings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeRelatedDocumentation = true;
acquireFilesSettings.OptionsRelationshipGathering.FileRelationshipSettings.RecurseChildren = false; // true?
acquireFilesSettings.OptionsRelationshipGathering.FileRelationshipSettings.VersionGatheringOption = VDF.Vault.Currency.VersionGatheringOption.Latest;;
acquireFilesSettings.LocalPath = new VDF.Currency.FolderPathAbsolute(tempPath);
acquireFilesSettings.AddFileToAcquire(fileIteration, /*VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Checkout | VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download*/ file.CheckedOut ? VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download : VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Checkout);
try
{
VDF.Vault.Results.AcquireFilesResults acquireFilesResults = connection.FileManager.AcquireFiles(acquireFilesSettings);
if (acquireFilesResults.FileResults.First().Status != VDF.Vault.Results.FileAcquisitionResult.AcquisitionStatus.Success)
{
return(false);
}
AWS.PropInstParam property = new AWS.PropInstParam {
PropDefId = definition.Get().Id, Val = value
};
connection.WebServiceManager.DocumentService.UpdateFileProperties(new long[] { file.MasterId }, new AWS.PropInstParamArray[] { new AWS.PropInstParamArray {
Items = new AWS.PropInstParam[] { property }
} });
List <AWS.FileAssocParam> newAssociations = FileOperations.UpdateFileAssociations(connection, fileIteration, oldAssociations.Get());
connection.FileManager.CheckinFile(fileIteration,
comment: "Updated property: " + propertyName + " to " + value.ToString(),
keepCheckedOut: false,
associations: newAssociations.ToArray(),
bom: null,
copyBom: false,
newFileName: null,
classification: fileIteration.FileClassification,
hidden: false,
filePath: new VDF.Currency.FilePathAbsolute(tempPath + "/" + file.Name));
return(true);
}
catch (Exception ex)
{
connection.FileManager.UndoCheckoutFile(fileIteration);
throw new ErrorMessageException("Child is checked out.");
}
}
/*****************************************************************************************/
public static Option <VDF.Vault.Results.AcquireFilesResults> CheckOutFile(VDF.Vault.Currency.Connections.Connection connection, AWS.File file, string localDirectoryPath, List <AWS.FileAssocLite> oldAssociations)
{
long userId = connection.UserID;
if (((file.CheckedOut) && (userId != file.CkOutUserId)) || (file.Locked))
{
return(Option.None);
}
VDF.Vault.Currency.Entities.FileIteration fileIteration = new VDF.Vault.Currency.Entities.FileIteration(connection, file);
Option <List <AWS.FileAssocLite> > oldAssocs = FileOperations.GetFileChildrenAssocsLite(connection, fileIteration);
if (oldAssocs.IsNone)
{
return(Option.None);
}
oldAssociations.AddRange(oldAssocs.Get());
AWS.FileAssocArray[] files = connection.WebServiceManager.DocumentService.GetLatestFileAssociationsByMasterIds(new long[] { file.MasterId }, AWS.FileAssociationTypeEnum.None, false, AWS.FileAssociationTypeEnum.Dependency, true, true, true, true);
bool childCheckedOutByOther = false;
foreach (AWS.FileAssocArray tempFiles in files)
{
try
{
foreach (AWS.FileAssoc tempFile in tempFiles.FileAssocs)
{
if ((tempFile.CldFile.CheckedOut) && (tempFile.CldFile.CkOutUserId == userId))
{
VDF.Vault.Currency.Entities.FileIteration tempIteration = new VDF.Vault.Currency.Entities.FileIteration(connection, tempFile.CldFile);
connection.FileManager.UndoCheckoutFile(tempIteration);
}
else if ((tempFile.CldFile.CheckedOut))
{
childCheckedOutByOther = true;
}
}
}
catch { }
}
if (childCheckedOutByOther)
{
return(Option.None);
}
VDF.Vault.Settings.AcquireFilesSettings acquireFilesSettings = new VDF.Vault.Settings.AcquireFilesSettings(connection, true);
acquireFilesSettings.OptionsResolution.OverwriteOption = VDF.Vault.Settings.AcquireFilesSettings.AcquireFileResolutionOptions.OverwriteOptions.ForceOverwriteAll;
acquireFilesSettings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeAttachments = false;
acquireFilesSettings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeChildren = false; // true?
acquireFilesSettings.OptionsRelationshipGathering.FileRelationshipSettings.IncludeRelatedDocumentation = true;
acquireFilesSettings.OptionsRelationshipGathering.FileRelationshipSettings.RecurseChildren = false; // true?
acquireFilesSettings.OptionsRelationshipGathering.FileRelationshipSettings.VersionGatheringOption = VDF.Vault.Currency.VersionGatheringOption.Latest;;
acquireFilesSettings.LocalPath = new VDF.Currency.FolderPathAbsolute(localDirectoryPath);
acquireFilesSettings.AddFileToAcquire(fileIteration, file.CheckedOut ? VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Download : VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Checkout);
try
{
VDF.Vault.Results.AcquireFilesResults acquireFilesResults = connection.FileManager.AcquireFiles(acquireFilesSettings);
if (acquireFilesResults.FileResults.First().Status != VDF.Vault.Results.FileAcquisitionResult.AcquisitionStatus.Success)
{
return(Option.None);
}
return(acquireFilesResults.AsOption());
}
catch
{
connection.FileManager.UndoCheckoutFile(fileIteration);
throw new ErrorMessageException("Child is checked out.");
}
}
