using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using ACET = Autodesk.Connectivity.Explorer.ExtensibilityTools;
using ACW = Autodesk.Connectivity.WebServices;
using VDF = Autodesk.DataManagement.Client.Framework;
using VltBase = Connectivity.Application.VaultBase;
using Autodesk.DataManagement.Client.Framework.Vault.Currency.Properties;
namespace QuickstartiLogicLibrary
{
public class QuickstartiLogicLib
{
private void Dispose()
{
}
private readonly VDF.Vault.Currency.Connections.Connection conn = VltBase.ConnectionManager.Instance.Connection;
private static readonly ACW.Product[] mProducts = VltBase.ConnectionManager.Instance.Connection.WebServiceManager.InformationService.GetSupportedProducts();
private readonly bool IsVaultPro = mIsVaultPro;
private readonly bool IsVaultBasic = mIsVaultBasic;
private static bool mIsVaultBasic
{
get
{
if (mProducts.Length == 1)
{
return true;
}
return false;
}
}
private static bool mIsVaultPro
{
get
{
if (mProducts.Length == 4)
{
return true;
}
return false;
}
}
private ACW.PropDef[] propDefs = null;
public bool LoggedIn
{
get
{
if (conn != null)
{
return true;
}
return false;
}
}
public VDF.Vault.Currency.Connections.Connection GetVaultConnection()
{
if (conn != null)
{
return conn;
}
return null;
}
public bool AddFile(string FullFileName, string VaultFolderPath, bool UpdateExisting = true, string ParentFileToAttachTo = null)
{
System.IO.FileInfo mLocalFileInfo = new System.IO.FileInfo(FullFileName);
Autodesk.Connectivity.WebServicesTools.WebServiceManager mWsMgr = conn.WebServiceManager;
ACW.Folder mFolder = mWsMgr.DocumentService.FindFoldersByPaths(new string[] { VaultFolderPath }).FirstOrDefault();
if (mFolder.Id == -1)
{
return false;
}
string vaultFilePath = System.IO.Path.Combine(mFolder.FullName, mLocalFileInfo.Name).Replace("\\", "/");
ACW.File wsFile = mWsMgr.DocumentService.FindLatestFilesByPaths(new string[] { vaultFilePath }).First();
VDF.Currency.FilePathAbsolute vdfPath = new VDF.Currency.FilePathAbsolute(mLocalFileInfo.FullName);
VDF.Vault.Currency.Entities.FileIteration vdfFile = null;
VDF.Vault.Currency.Entities.FileIteration mUploadedFile = null;
if (wsFile.Id == -1)
{
var folderEntity = new Autodesk.DataManagement.Client.Framework.Vault.Currency.Entities.Folder(conn, mFolder);
try
{
mUploadedFile = conn.FileManager.AddFile(folderEntity, "Added by iLogic-Vault rule", null, null, ACW.FileClassification.None, false, vdfPath);
}
catch (Exception)
{
return false;
}
}
else
{
if (UpdateExisting == true)
{
VDF.Vault.Settings.AcquireFilesSettings mCheckOutSettings = new VDF.Vault.Settings.AcquireFilesSettings(conn)
{
DefaultAcquisitionOption = VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Checkout
};
vdfFile = new VDF.Vault.Currency.Entities.FileIteration(conn, wsFile);
mCheckOutSettings.AddEntityToAcquire(vdfFile);
var results = conn.FileManager.AcquireFiles(mCheckOutSettings);
try
{
mUploadedFile = conn.FileManager.CheckinFile(results.FileResults.First().File, "Created by iLogic-Vault rule", false, null, null, false, null, ACW.FileClassification.None, false, vdfPath);
}
catch (Exception)
{
return false;
}
}
}
if (ParentFileToAttachTo == null)
{
return true;
}
else
{
ACW.File mParentFile = mWsMgr.DocumentService.FindLatestFilesByPaths(new string[] { ParentFileToAttachTo }).First();
if (mParentFile.Id == -1)
{
return false;
}
else
{
VDF.Vault.Currency.Entities.FileIteration mParFileIteration = new VDF.Vault.Currency.Entities.FileIteration(conn, mParentFile);
try
{
VDF.Vault.Settings.AcquireFilesSettings mCheckOutSettings = new VDF.Vault.Settings.AcquireFilesSettings(conn)
{
DefaultAcquisitionOption = VDF.Vault.Settings.AcquireFilesSettings.AcquisitionOption.Checkout
};
mCheckOutSettings.CheckoutComment = "iLogic-Vault Rule is about attaching an uploaded file.";
mCheckOutSettings.AddEntityToAcquire(mParFileIteration);
VDF.Vault.Results.AcquireFilesResults acquireFilesResults = conn.FileManager.AcquireFiles(mCheckOutSettings);
if (acquireFilesResults.IsCancelled != true && acquireFilesResults.FileResults.First().Status == VDF.Vault.Results.FileAcquisitionResult.AcquisitionStatus.Success)
{
VDF.Vault.Currency.Entities.FileIteration mNewFileIteration = acquireFilesResults.FileResults.First().NewFileIteration;
VDF.Vault.Settings.FileRelationshipGatheringSettings fileRelationshipGatheringSettings = new VDF.Vault.Settings.FileRelationshipGatheringSettings();
fileRelationshipGatheringSettings.IncludeAttachments = true;
fileRelationshipGatheringSettings.IncludeChildren = true;
fileRelationshipGatheringSettings.IncludeRelatedDocumentation = true;
fileRelationshipGatheringSettings.IncludeParents = false;
fileRelationshipGatheringSettings.IncludeHiddenEntities = true;
fileRelationshipGatheringSettings.IncludeLibraryContents = true;
IEnumerable<ACW.FileAssocLite> fileAssocsLite = conn.FileManager.GetFileAssociationLites(new long[] { mNewFileIteration.EntityIterationId },
fileRelationshipGatheringSettings);
List<ACW.FileAssocParam> fileAssocParams = new List<ACW.FileAssocParam>();
foreach (ACW.FileAssocLite item in fileAssocsLite)
{
if (item.ParFileId == mNewFileIteration.EntityIterationId && item.CldFileId != mUploadedFile.EntityIterationId)
{
ACW.FileAssocParam param = new ACW.FileAssocParam();
param.Typ = item.Typ;
param.RefId = item.RefId;
param.Source = item.Source;
param.CldFileId = item.CldFileId;
param.ExpectedVaultPath = item.ExpectedVaultPath;
fileAssocParams.Add(param);
}
}
ACW.FileAssocParam mNewParam = new ACW.FileAssocParam();
mNewParam.Typ = ACW.AssociationType.Attachment;
mNewParam.RefId = "";
mNewParam.Source = "";
mNewParam.CldFileId = mUploadedFile.EntityIterationId;
mNewParam.ExpectedVaultPath = mFolder.FullName + "/" + mUploadedFile.EntityName;
fileAssocParams.Add(mNewParam);
ACW.FileAssocParam[] mFileAssocParamArray = (ACW.FileAssocParam[])fileAssocParams.ToArray();
System.IO.Stream stream = null;
VDF.Vault.Currency.Entities.FileIteration mUpdatedParent;
try
{
mUpdatedParent = conn.FileManager.CheckinFile(mNewFileIteration, "iLogic Rule modified Attachments", false, mFileAssocParamArray, null, true, mNewFileIteration.EntityName, mNewFileIteration.FileClassification, false);
}
catch (Exception)
{
mUpdatedParent = conn.FileManager.UndoCheckoutFile(mNewFileIteration, stream);
return false;
}
}
}
catch (Exception)
{
return false;
}
}
return true;
}
}
public IList<string> CheckFilesExistBySearchCriteria(Dictionary<string, string> SearchCriteria, bool MatchAllCriteria = true, string[] FoldersSearched = null)
{
ACW.Folder[] mFldr;
List<long> mFolders = new List<long>();
if (FoldersSearched != null)
{
mFldr = conn.WebServiceManager.DocumentService.FindFoldersByPaths(FoldersSearched);
foreach (ACW.Folder folder in mFldr)
{
if (folder.Id != -1) mFolders.Add(folder.Id);
}
}
List<String> mFilesFound = new List<string>();
List<ACW.SrchCond> mSrchConds = CreateSrchConds(SearchCriteria, MatchAllCriteria);
List<ACW.File> totalResults = new List<ACW.File>();
string bookmark = string.Empty;
ACW.SrchStatus status = null;
while (status == null || totalResults.Count < status.TotalHits)
{
ACW.File[] mSrchResults = conn.WebServiceManager.DocumentService.FindFilesBySearchConditions(
mSrchConds.ToArray(), null, mFolders.ToArray(), true, true, ref bookmark, out status);
if (mSrchResults != null) totalResults.AddRange(mSrchResults);
else break;
}
if (totalResults.Count >= 1)
{
foreach (ACW.File wsFile in totalResults)
{
mFilesFound.Add(wsFile.Name);
}
return mFilesFound;
}
else
{
return null;
}
}
public IList<string> CheckFilesExistBySearchCriteria(Dictionary<string, string> SearchCriteria, ref Dictionary<string, Dictionary<string, string>> AllFilesVaultFileProperties,
bool MatchAllCriteria = true, string[] FoldersSearched = null)
{
ACW.Folder[] mFldr;
List<long> mFolders = new List<long>();
if (FoldersSearched != null)
{
mFldr = conn.WebServiceManager.DocumentService.FindFoldersByPaths(FoldersSearched);
foreach (ACW.Folder folder in mFldr)
{
if (folder.Id != -1) mFolders.Add(folder.Id);
}
}
List<String> mFilesFound = new List<string>();
List<ACW.SrchCond> mSrchConds = CreateSrchConds(SearchCriteria, MatchAllCriteria);
List<ACW.File> totalResults = new List<ACW.File>();
string bookmark = string.Empty;
ACW.SrchStatus status = null;
while (status == null || totalResults.Count < status.TotalHits)
{
ACW.File[] mSrchResults = conn.WebServiceManager.DocumentService.FindFilesBySearchConditions(
mSrchConds.ToArray(), null, mFolders.ToArray(), true, true, ref bookmark, out status);
if (mSrchResults != null) totalResults.AddRange(mSrchResults);
else break;
}
if (totalResults.Count >= 1)
{
foreach (ACW.File wsFile in totalResults)
{
mFilesFound.Add(wsFile.Name);
Dictionary<string, string> mVaultFileProperties = new Dictionary<string, string>();
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, wsFile);
mGetFileProps(mFileIt, ref mVaultFileProperties);
AllFilesVaultFileProperties.Add(mFileIt.EntityName, (mVaultFileProperties));
}
return mFilesFound;
}
else
{
return null;
}
}
public Dictionary<string, string> GetVaultFileStatus(string LocalFullFileName)
{
Dictionary<string, string> keyValues = new Dictionary<string, string>();
System.IO.FileInfo fileInfo = new System.IO.FileInfo(LocalFullFileName);
string mVltFullFileName = null;
string mWf = conn.WorkingFoldersManager.GetWorkingFolder("$/").FullPath;
if (LocalFullFileName.ToLower().Contains(mWf.ToLower()))
mVltFullFileName = LocalFullFileName.Replace(mWf, "$/");
mVltFullFileName = mVltFullFileName.Replace("\\", "/");
Autodesk.Connectivity.WebServicesTools.WebServiceManager mWsMgr = conn.WebServiceManager;
ACW.File mFile = mWsMgr.DocumentService.FindLatestFilesByPaths(new string[] { mVltFullFileName }).FirstOrDefault();
if (mFile.Id == -1)
{
if (!fileInfo.Exists)
{
keyValues.Add("ErrorState", "LocalFileNotFoundVaultFileNotFound");
}
else
{
keyValues.Add("ErrorState", "VaultFileNotFound");
}
return keyValues;
}
VDF.Vault.Currency.Entities.FileIteration mFileIteration = new VDF.Vault.Currency.Entities.FileIteration(conn, mFile);
PropertyDefinitionDictionary mProps = conn.PropertyManager.GetPropertyDefinitions(VDF.Vault.Currency.Entities.EntityClassIds.Files, null, PropertyDefinitionFilter.IncludeAll);
PropertyDefinition mVaultStatus = mProps[PropertyDefinitionIds.Client.VaultStatus];
EntityStatusImageInfo status = conn.PropertyManager.GetPropertyValue(mFileIteration, mVaultStatus, null) as EntityStatusImageInfo;
keyValues.Add("CheckOutState", status.Status.CheckoutState.ToString());
keyValues.Add("ConsumableState", status.Status.ConsumableState.ToString());
keyValues.Add("ErrorState", status.Status.ErrorState.ToString());
keyValues.Add("LocalEditsState", status.Status.LocalEditsState.ToString());
keyValues.Add("LockState", status.Status.LockState.ToString());
keyValues.Add("RevisionState", status.Status.RevisionState.ToString());
keyValues.Add("VersionState", status.Status.VersionState.ToString());
return keyValues;
}
public string ConvertLocalPathToVaultPath(string LocalPath)
{
string mVaultPath = null;
string mWf = conn.WorkingFoldersManager.GetWorkingFolder("$/").FullPath;
if (LocalPath.Contains(mWf))
{
if (IsFilePath(LocalPath) == true)
{
System.IO.FileInfo fileInfo = new System.IO.FileInfo(LocalPath);
LocalPath = fileInfo.DirectoryName;
}
if (IsDirPath(LocalPath) == true)
{
mVaultPath = LocalPath.Replace(mWf, "$/");
mVaultPath = mVaultPath.Replace("\\", "/");
return mVaultPath;
}
else
{
return "Invalid local path";
}
}
else
{
return "Error: Local path outside of working folder";
}
}
public string GetFileByFullFilePath(string VaultFullFileName, bool CheckOut = false)
{
List<string> mFiles = new List<string>();
List<String> mFilesDownloaded = new List<string>();
mFiles.Add(VaultFullFileName);
ACW.File[] wsFiles = conn.WebServiceManager.DocumentService.FindLatestFilesByPaths(mFiles.ToArray());
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFiles[0]));
if (mFileIt.EntityMasterId != -1)
{
VDF.Vault.Settings.AcquireFilesSettings settings = CreateAcquireSettings(false);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (results.FileResults != null)
{
if (results.FileResults.Any(n => n.File.EntityName == mFileIt.EntityName))
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
if (results.IsCancelled == true)
{
PropertyDefinitionDictionary mProps = conn.PropertyManager.GetPropertyDefinitions(VDF.Vault.Currency.Entities.EntityClassIds.Files, null, PropertyDefinitionFilter.IncludeAll);
PropertyDefinition mVaultStatus = mProps[PropertyDefinitionIds.Client.VaultStatus];
EntityStatusImageInfo mStatus = conn.PropertyManager.GetPropertyValue(mFileIt, mVaultStatus, null) as EntityStatusImageInfo;
if (mStatus.Status.ConsumableState == EntityStatus.ConsumableStateEnum.LatestConsumable)
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
if (CheckOut)
{
settings = CreateAcquireSettings(true);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
results = conn.FileManager.AcquireFiles(settings);
}
if (mFilesDownloaded.Count > 0)
{
return mFilesDownloaded[0];
}
else
{
return null;
}
}
return null;
}
public string GetFileByFullFilePath(string VaultFullFileName, ref Dictionary<string, string> VaultFileProperties, bool CheckOut = false)
{
List<string> mFiles = new List<string>();
List<String> mFilesDownloaded = new List<string>();
mFiles.Add(VaultFullFileName);
ACW.File[] wsFiles = conn.WebServiceManager.DocumentService.FindLatestFilesByPaths(mFiles.ToArray());
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFiles[0]));
if (mFileIt.EntityMasterId != -1)
{
VDF.Vault.Settings.AcquireFilesSettings settings = CreateAcquireSettings(false);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (results.FileResults != null)
{
if (results.FileResults.Any(n => n.File.EntityName == mFileIt.EntityName))
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
if (results.IsCancelled == true)
{
PropertyDefinitionDictionary mProps = conn.PropertyManager.GetPropertyDefinitions(VDF.Vault.Currency.Entities.EntityClassIds.Files, null, PropertyDefinitionFilter.IncludeAll);
PropertyDefinition mVaultStatus = mProps[PropertyDefinitionIds.Client.VaultStatus];
EntityStatusImageInfo mStatus = conn.PropertyManager.GetPropertyValue(mFileIt, mVaultStatus, null) as EntityStatusImageInfo;
if (mStatus.Status.ConsumableState == EntityStatus.ConsumableStateEnum.LatestConsumable)
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
if (CheckOut)
{
settings = CreateAcquireSettings(true);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
results = conn.FileManager.AcquireFiles(settings);
}
if (mFilesDownloaded.Count > 0)
{
mGetFileProps(mFileIt, ref VaultFileProperties);
return mFilesDownloaded[0];
}
else
{
return null;
}
}
return null;
}
public string GetFileByFullFilePath(string VaultFullFileName, ref Dictionary<string, string> VaultFileProperties,
ref Dictionary<string, string> VaultItemProperties, bool CheckOut = false)
{
if (IsVaultBasic)
{
MessageBox.Show("The iLogic-Vault method GetFileByFullFilePath overload including Item properties is not available for Vault Basic", "iLogic-Vault", MessageBoxButtons.OK, MessageBoxIcon.Error);
return null;
}
List<string> mFiles = new List<string>();
List<String> mFilesDownloaded = new List<string>();
mFiles.Add(VaultFullFileName);
ACW.File[] wsFiles = conn.WebServiceManager.DocumentService.FindLatestFilesByPaths(mFiles.ToArray());
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFiles[0]));
if (mFileIt.EntityMasterId != -1)
{
VDF.Vault.Settings.AcquireFilesSettings settings = CreateAcquireSettings(false);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (results.FileResults != null)
{
if (results.FileResults.Any(n => n.File.EntityName == mFileIt.EntityName))
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
if (results.IsCancelled == true)
{
PropertyDefinitionDictionary mProps = conn.PropertyManager.GetPropertyDefinitions(VDF.Vault.Currency.Entities.EntityClassIds.Files, null, PropertyDefinitionFilter.IncludeAll);
PropertyDefinition mVaultStatus = mProps[PropertyDefinitionIds.Client.VaultStatus];
EntityStatusImageInfo mStatus = conn.PropertyManager.GetPropertyValue(mFileIt, mVaultStatus, null) as EntityStatusImageInfo;
if (mStatus.Status.ConsumableState == EntityStatus.ConsumableStateEnum.LatestConsumable)
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
if (CheckOut)
{
settings = CreateAcquireSettings(true);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
results = conn.FileManager.AcquireFiles(settings);
}
if (mFilesDownloaded.Count > 0)
{
mGetFileProps(mFileIt, ref VaultFileProperties);
ACW.Item[] items = conn.WebServiceManager.ItemService.GetItemsByFileId(mFileIt.EntityIterationId);
if (items.Length > 0)
{
ACW.Item item = items[0];
mGetItemProps(item, ref VaultItemProperties);
}
return mFilesDownloaded[0];
}
else
{
return null;
}
}
return null;
}
public string GetFileCopyBySourceFileNameAndAutoNumber(string VaultFullFileName, string NumberingScheme, string[] InputParams = null, bool CheckOut = true, bool UpdatePartNumber = true)
{
if (IsVaultBasic)
{
MessageBox.Show("The iLogic-Vault method GetFileCopyBySourceFileNameAndAutoNumber is not available for Vault Basic", "iLogic-Vault", MessageBoxButtons.OK, MessageBoxIcon.Error);
return null;
}
List<string> mFiles = new List<string>();
List<String> mFilesDownloaded = new List<string>();
mFiles.Add(VaultFullFileName);
ACW.File mSourceFile = conn.WebServiceManager.DocumentService.FindLatestFilesByPaths(mFiles.ToArray()).First();
if (mSourceFile.Name == null) return null;
string mNewNumber = GetNewNumber(NumberingScheme, InputParams);
if (mNewNumber == null) return null;
string mNewFileName = String.Format("{0}{1}{2}", mNewNumber, ".", (mSourceFile.Name).Split('.').Last());
VDF.Vault.Currency.Entities.FileIteration mFileIt = CreateFileCopy(mSourceFile, mNewFileName);
if (UpdatePartNumber)
{
Dictionary<ACW.PropDef, object> mPropDictonary = new Dictionary<ACW.PropDef, object>();
if (propDefs == null)
{
propDefs = conn.WebServiceManager.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
}
ACW.PropDef propDef = propDefs.SingleOrDefault(n => n.SysName == "PartNumber");
mPropDictonary.Add(propDef, mNewNumber);
mUpdateFileProperties((ACW.File)mFileIt, mPropDictonary);
mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, conn.WebServiceManager.DocumentService.GetLatestFileByMasterId(mFileIt.EntityMasterId));
}
VDF.Vault.Settings.AcquireFilesSettings settings = CreateAcquireSettings(false);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (CheckOut)
{
settings = CreateAcquireSettings(true);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
results = conn.FileManager.AcquireFiles(settings);
}
if (results != null)
try
{
if (results.FileResults.Any(n => n.File.EntityName == mFileIt.EntityName))
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
return mFilesDownloaded[0];
}
catch (Exception)
{
return null;
}
return null;
}
public string GetFileCopyBySourceFileNameAndNewName(string VaultFullFileName, string NewFileNameNoExt, bool CheckOut = true, bool UpdatePartNumber = true)
{
if (IsVaultBasic)
{
MessageBox.Show("The iLogic-Vault method GetFileCopyBySourceFileNameAndNewName is not available for Vault Basic", "iLogic-Vault", MessageBoxButtons.OK, MessageBoxIcon.Error);
return null;
}
List<string> mFiles = new List<string>();
List<String> mFilesDownloaded = new List<string>();
mFiles.Add(VaultFullFileName);
ACW.File mSourceFile = conn.WebServiceManager.DocumentService.FindLatestFilesByPaths(mFiles.ToArray()).First();
if (mSourceFile == null) return null;
string mNewFileName = String.Format("{0}{1}{2}", NewFileNameNoExt, ".", (mSourceFile.Name).Split('.').Last());
VDF.Vault.Currency.Entities.FileIteration mFileIt = CreateFileCopy(mSourceFile, mNewFileName);
if (UpdatePartNumber)
{
Dictionary<ACW.PropDef, object> mPropDictonary = new Dictionary<ACW.PropDef, object>();
ACW.PropDef[] propDefs = conn.WebServiceManager.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
ACW.PropDef propDef = propDefs.SingleOrDefault(n => n.SysName == "PartNumber");
mPropDictonary.Add(propDef, mNewFileName);
mUpdateFileProperties(mFileIt, mPropDictonary);
mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, conn.WebServiceManager.DocumentService.GetLatestFileByMasterId(mFileIt.EntityMasterId));
}
VDF.Vault.Settings.AcquireFilesSettings settings = CreateAcquireSettings(false);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (CheckOut)
{
settings = CreateAcquireSettings(true);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
results = conn.FileManager.AcquireFiles(settings);
}
if (results != null)
{
try
{
if (results.FileResults.Any(n => n.File.EntityName == mFileIt.EntityName))
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
return mFilesDownloaded[0];
}
catch (Exception)
{
return null;
}
}
return null;
}
public string GetFileBySearchCriteria(Dictionary<string, string> SearchCriteria, bool MatchAllCriteria = true, bool CheckOut = false, string[] FoldersSearched = null)
{
ACW.Folder[] mFldr;
List<long> mFolders = new List<long>();
if (FoldersSearched != null)
{
mFldr = conn.WebServiceManager.DocumentService.FindFoldersByPaths(FoldersSearched);
foreach (ACW.Folder folder in mFldr)
{
if (folder.Id != -1) mFolders.Add(folder.Id);
}
}
List<String> mFilesFound = new List<string>();
List<String> mFilesDownloaded = new List<string>();
List<ACW.SrchCond> mSrchConds = CreateSrchConds(SearchCriteria, MatchAllCriteria);
List<ACW.File> totalResults = new List<ACW.File>();
string bookmark = string.Empty;
ACW.SrchStatus status = null;
while (status == null || totalResults.Count < status.TotalHits)
{
ACW.File[] mSrchResults = conn.WebServiceManager.DocumentService.FindFilesBySearchConditions(
mSrchConds.ToArray(), null, mFolders.ToArray(), true, true, ref bookmark, out status);
if (mSrchResults != null) totalResults.AddRange(mSrchResults);
else break;
}
if (totalResults.Count >= 1)
{
ACW.File wsFile = totalResults.First<ACW.File>();
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFile));
VDF.Vault.Settings.AcquireFilesSettings settings = CreateAcquireSettings(false);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (results.FileResults != null)
{
if (results.FileResults.Any(n => n.File.EntityName == mFileIt.EntityName))
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
if (results.IsCancelled == true)
{
PropertyDefinitionDictionary mProps = conn.PropertyManager.GetPropertyDefinitions(VDF.Vault.Currency.Entities.EntityClassIds.Files, null, PropertyDefinitionFilter.IncludeAll);
PropertyDefinition mVaultStatus = mProps[PropertyDefinitionIds.Client.VaultStatus];
EntityStatusImageInfo mStatus = conn.PropertyManager.GetPropertyValue(mFileIt, mVaultStatus, null) as EntityStatusImageInfo;
if (mStatus.Status.ConsumableState == EntityStatus.ConsumableStateEnum.LatestConsumable)
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
if (CheckOut)
{
settings = CreateAcquireSettings(true);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
results = conn.FileManager.AcquireFiles(settings);
}
if (mFilesDownloaded.Count > 0)
{
return mFilesDownloaded[0];
}
else
{
return null;
}
}
else
{
return null;
}
}
public string GetFileBySearchCriteria(Dictionary<string, string> SearchCriteria, ref Dictionary<string, string> VaultFileProperties, bool MatchAllCriteria = true, bool CheckOut = false, string[] FoldersSearched = null)
{
ACW.Folder[] mFldr;
List<long> mFolders = new List<long>();
if (FoldersSearched != null)
{
mFldr = conn.WebServiceManager.DocumentService.FindFoldersByPaths(FoldersSearched);
foreach (ACW.Folder folder in mFldr)
{
if (folder.Id != -1) mFolders.Add(folder.Id);
}
}
List<String> mFilesFound = new List<string>();
List<String> mFilesDownloaded = new List<string>();
List<ACW.SrchCond> mSrchConds = CreateSrchConds(SearchCriteria, MatchAllCriteria);
List<ACW.File> totalResults = new List<ACW.File>();
string bookmark = string.Empty;
ACW.SrchStatus status = null;
while (status == null || totalResults.Count < status.TotalHits)
{
ACW.File[] mSrchResults = conn.WebServiceManager.DocumentService.FindFilesBySearchConditions(
mSrchConds.ToArray(), null, mFolders.ToArray(), true, true, ref bookmark, out status);
if (mSrchResults != null) totalResults.AddRange(mSrchResults);
else break;
}
if (totalResults.Count >= 1)
{
ACW.File wsFile = totalResults.First<ACW.File>();
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFile));
VDF.Vault.Settings.AcquireFilesSettings settings = CreateAcquireSettings(false);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (results.FileResults != null)
{
if (results.FileResults.Any(n => n.File.EntityName == mFileIt.EntityName))
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
if (results.IsCancelled == true)
{
PropertyDefinitionDictionary mProps = conn.PropertyManager.GetPropertyDefinitions(VDF.Vault.Currency.Entities.EntityClassIds.Files, null, PropertyDefinitionFilter.IncludeAll);
PropertyDefinition mVaultStatus = mProps[PropertyDefinitionIds.Client.VaultStatus];
EntityStatusImageInfo mStatus = conn.PropertyManager.GetPropertyValue(mFileIt, mVaultStatus, null) as EntityStatusImageInfo;
if (mStatus.Status.ConsumableState == EntityStatus.ConsumableStateEnum.LatestConsumable)
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
if (CheckOut)
{
settings = CreateAcquireSettings(true);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
results = conn.FileManager.AcquireFiles(settings);
}
if (mFilesDownloaded.Count > 0)
{
mGetFileProps(mFileIt, ref VaultFileProperties);
return mFilesDownloaded[0];
}
else
{
return null;
}
}
else
{
return null;
}
}
public string GetFileBySearchCriteria(Dictionary<string, string> SearchCriteria, ref Dictionary<string, string> VaultFileProperties,
ref Dictionary<string, string> VaultItemProperties, bool MatchAllCriteria = true, bool CheckOut = false, string[] FoldersSearched = null)
{
ACW.Folder[] mFldr;
List<long> mFolders = new List<long>();
if (FoldersSearched != null)
{
mFldr = conn.WebServiceManager.DocumentService.FindFoldersByPaths(FoldersSearched);
foreach (ACW.Folder folder in mFldr)
{
if (folder.Id != -1) mFolders.Add(folder.Id);
}
}
List<String> mFilesFound = new List<string>();
List<String> mFilesDownloaded = new List<string>();
List<ACW.SrchCond> mSrchConds = CreateSrchConds(SearchCriteria, MatchAllCriteria);
List<ACW.File> totalResults = new List<ACW.File>();
string bookmark = string.Empty;
ACW.SrchStatus status = null;
while (status == null || totalResults.Count < status.TotalHits)
{
ACW.File[] mSrchResults = conn.WebServiceManager.DocumentService.FindFilesBySearchConditions(
mSrchConds.ToArray(), null, mFolders.ToArray(), true, true, ref bookmark, out status);
if (mSrchResults != null) totalResults.AddRange(mSrchResults);
else break;
}
if (totalResults.Count >= 1)
{
ACW.File wsFile = totalResults.First<ACW.File>();
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFile));
VDF.Vault.Settings.AcquireFilesSettings settings = CreateAcquireSettings(false);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (results.FileResults != null)
{
if (results.FileResults.Any(n => n.File.EntityName == mFileIt.EntityName))
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
if (results.IsCancelled == true)
{
PropertyDefinitionDictionary mProps = conn.PropertyManager.GetPropertyDefinitions(VDF.Vault.Currency.Entities.EntityClassIds.Files, null, PropertyDefinitionFilter.IncludeAll);
PropertyDefinition mVaultStatus = mProps[PropertyDefinitionIds.Client.VaultStatus];
EntityStatusImageInfo mStatus = conn.PropertyManager.GetPropertyValue(mFileIt, mVaultStatus, null) as EntityStatusImageInfo;
if (mStatus.Status.ConsumableState == EntityStatus.ConsumableStateEnum.LatestConsumable)
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
if (CheckOut)
{
settings = CreateAcquireSettings(true);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
results = conn.FileManager.AcquireFiles(settings);
}
if (mFilesDownloaded.Count > 0)
{
mGetFileProps(mFileIt, ref VaultFileProperties);
ACW.Item[] items = conn.WebServiceManager.ItemService.GetItemsByFileId(mFileIt.EntityIterationId);
if (items.Length > 0)
{
ACW.Item item = items[0];
mGetItemProps(item, ref VaultItemProperties);
}
return mFilesDownloaded[0];
}
else
{
return null;
}
}
else
{
return null;
}
}
public IList<string> GetFilesBySearchCriteria(Dictionary<string, string> SearchCriteria, bool MatchAllCriteria = true, bool CheckOut = false, string[] FoldersSearched = null)
{
ACW.Folder[] mFldr;
List<long> mFolders = new List<long>();
if (FoldersSearched != null)
{
mFldr = conn.WebServiceManager.DocumentService.FindFoldersByPaths(FoldersSearched);
foreach (ACW.Folder folder in mFldr)
{
if (folder.Id != -1) mFolders.Add(folder.Id);
}
}
List<VDF.Vault.Currency.Entities.FileIteration> mFilesFound = new List<VDF.Vault.Currency.Entities.FileIteration>();
List<String> mFilesDownloaded = new List<string>();
List<ACW.SrchCond> mSrchConds = CreateSrchConds(SearchCriteria, MatchAllCriteria);
List<ACW.File> totalResults = new List<ACW.File>();
string bookmark = string.Empty;
ACW.SrchStatus status = null;
while (status == null || totalResults.Count < status.TotalHits)
{
ACW.File[] mSrchResults = conn.WebServiceManager.DocumentService.FindFilesBySearchConditions(
mSrchConds.ToArray(), null, mFolders.ToArray(), true, true, ref bookmark, out status);
if (mSrchResults != null) totalResults.AddRange(mSrchResults);
else break;
}
if (totalResults.Count >= 1)
{
VDF.Vault.Settings.AcquireFilesSettings settings = CreateAcquireSettings(false);
foreach (ACW.File wsFile in totalResults)
{
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, wsFile);
mFilesFound.Add(mFileIt);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
}
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (results.FileResults != null)
{
foreach (VDF.Vault.Currency.Entities.FileIteration mFileIt in mFilesFound)
{
if (results.FileResults.Any(n => n.File.EntityName == mFileIt.EntityName))
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
}
if (results.IsCancelled == true)
{
foreach (VDF.Vault.Currency.Entities.FileIteration mFileIt in mFilesFound)
{
PropertyDefinitionDictionary mProps = conn.PropertyManager.GetPropertyDefinitions(VDF.Vault.Currency.Entities.EntityClassIds.Files, null, PropertyDefinitionFilter.IncludeAll);
PropertyDefinition mVaultStatus = mProps[PropertyDefinitionIds.Client.VaultStatus];
EntityStatusImageInfo mStatus = conn.PropertyManager.GetPropertyValue(mFileIt, mVaultStatus, null) as EntityStatusImageInfo;
if (mStatus.Status.ConsumableState == EntityStatus.ConsumableStateEnum.LatestConsumable)
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
}
}
if (CheckOut)
{
settings = CreateAcquireSettings(true);
foreach (ACW.File wsFile in totalResults)
{
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, wsFile);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
}
results = conn.FileManager.AcquireFiles(settings);
}
if (mFilesDownloaded.Count > 0)
{
return mFilesDownloaded;
}
return null;
}
else
{
return null;
}
}
public string GetFileCopyBySourceFileSearchAndAutoNumber(Dictionary<string, string> SearchCriteria, string NumberingScheme, bool MatchAllCriteria = true, string[] InputParams = null, bool CheckOut = true, string[] FoldersSearched = null, bool UpdatePartNumber = true)
{
if (IsVaultBasic)
{
MessageBox.Show("The iLogic-Vault method GetFileCopyBySourceFileSearchAndAutoNumber is not available for Vault Basic", "iLogic-Vault", MessageBoxButtons.OK, MessageBoxIcon.Error);
return null;
}
ACW.Folder[] mFldr;
List<long> mFolders = new List<long>();
if (FoldersSearched != null)
{
mFldr = conn.WebServiceManager.DocumentService.FindFoldersByPaths(FoldersSearched);
foreach (ACW.Folder folder in mFldr)
{
if (folder.Id != -1) mFolders.Add(folder.Id);
}
}
List<String> mFilesFound = new List<string>();
List<String> mFilesDownloaded = new List<string>();
List<ACW.SrchCond> mSrchConds = CreateSrchConds(SearchCriteria, MatchAllCriteria);
List<ACW.File> totalResults = new List<ACW.File>();
string bookmark = string.Empty;
ACW.SrchStatus status = null;
while (status == null || totalResults.Count < status.TotalHits)
{
ACW.File[] mSrchResults = conn.WebServiceManager.DocumentService.FindFilesBySearchConditions(
mSrchConds.ToArray(), null, mFolders.ToArray(), true, true, ref bookmark, out status);
if (mSrchResults != null) totalResults.AddRange(mSrchResults);
else break;
}
if (totalResults.Count >= 1)
{
ACW.File mSourceFile = totalResults.First<ACW.File>();
if (mSourceFile == null) return null;
string mNewNumber = GetNewNumber(NumberingScheme, InputParams);
if (mNewNumber == null) return null;
string mNewFileName = String.Format("{0}{1}{2}", mNewNumber, ".", (mSourceFile.Name).Split('.').Last());
VDF.Vault.Currency.Entities.FileIteration mFileIt = CreateFileCopy(mSourceFile, mNewFileName);
if (UpdatePartNumber)
{
Dictionary<ACW.PropDef, object> mPropDictonary = new Dictionary<ACW.PropDef, object>();
ACW.PropDef[] propDefs = conn.WebServiceManager.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
ACW.PropDef propDef = propDefs.SingleOrDefault(n => n.SysName == "PartNumber");
mPropDictonary.Add(propDef, mNewNumber);
mUpdateFileProperties((ACW.File)mFileIt, mPropDictonary);
mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, conn.WebServiceManager.DocumentService.GetLatestFileByMasterId(mFileIt.EntityMasterId));
}
VDF.Vault.Settings.AcquireFilesSettings settings = CreateAcquireSettings(false);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (CheckOut)
{
settings = CreateAcquireSettings(true);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
results = conn.FileManager.AcquireFiles(settings);
}
if (results != null)
{
try
{
if (results.FileResults.Any(n => n.File.EntityName == mFileIt.EntityName))
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
return mFilesDownloaded[0];
}
catch (Exception)
{
return null;
}
}
else
{
return null;
}
}
else
{
return null;
}
}
public string GetFileCopyBySourceFileSearchAndNewName(Dictionary<string, string> SearchCriteria, string NewFileNameNoExt, bool MatchAllCriteria = true, bool CheckOut = true, string[] FoldersSearched = null, bool UpdatePartNumber = true)
{
if (IsVaultBasic)
{
MessageBox.Show("The iLogic-Vault method GetFileCopyBySourceFileSearchAndNewName is not available for Vault Basic", "iLogic-Vault", MessageBoxButtons.OK, MessageBoxIcon.Error);
return null;
}
ACW.Folder[] mFldr;
List<long> mFolders = new List<long>();
if (FoldersSearched != null)
{
mFldr = conn.WebServiceManager.DocumentService.FindFoldersByPaths(FoldersSearched);
foreach (ACW.Folder folder in mFldr)
{
if (folder.Id != -1) mFolders.Add(folder.Id);
}
}
List<String> mFilesFound = new List<string>();
List<String> mFilesDownloaded = new List<string>();
List<ACW.SrchCond> mSrchConds = CreateSrchConds(SearchCriteria, MatchAllCriteria);
List<ACW.File> totalResults = new List<ACW.File>();
string bookmark = string.Empty;
ACW.SrchStatus status = null;
while (status == null || totalResults.Count < status.TotalHits)
{
ACW.File[] mSrchResults = conn.WebServiceManager.DocumentService.FindFilesBySearchConditions(
mSrchConds.ToArray(), null, mFolders.ToArray(), true, true, ref bookmark, out status);
if (mSrchResults != null) totalResults.AddRange(mSrchResults);
else break;
}
if (totalResults.Count >= 1)
{
ACW.File mSourceFile = totalResults.First<ACW.File>();
if (mSourceFile == null) return null;
string mNewFileName = String.Format("{0}{1}{2}", NewFileNameNoExt, ".", (mSourceFile.Name).Split('.').Last());
VDF.Vault.Currency.Entities.FileIteration mFileIt = CreateFileCopy(mSourceFile, mNewFileName);
if (UpdatePartNumber)
{
Dictionary<ACW.PropDef, object> mPropDictonary = new Dictionary<ACW.PropDef, object>();
ACW.PropDef[] propDefs = conn.WebServiceManager.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
ACW.PropDef propDef = propDefs.SingleOrDefault(n => n.SysName == "PartNumber");
mPropDictonary.Add(propDef, mNewFileName);
mUpdateFileProperties(mFileIt, mPropDictonary);
mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, conn.WebServiceManager.DocumentService.GetLatestFileByMasterId(mFileIt.EntityMasterId));
}
VDF.Vault.Settings.AcquireFilesSettings settings = CreateAcquireSettings(false);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
VDF.Vault.Results.AcquireFilesResults results = conn.FileManager.AcquireFiles(settings);
if (CheckOut)
{
settings = CreateAcquireSettings(true);
settings.AddFileToAcquire(mFileIt, settings.DefaultAcquisitionOption);
results = conn.FileManager.AcquireFiles(settings);
}
if (results != null)
{
try
{
if (results.FileResults.Any(n => n.File.EntityName == mFileIt.EntityName))
{
mFilesDownloaded.Add(conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).FullPath.ToString());
}
return mFilesDownloaded[0];
}
catch (Exception)
{
return null;
}
}
else
{
return null;
}
}
else
{
return null;
}
}
public string GetNewNumber(string mSchmName, string[] mSchmPrms = null)
{
if (IsVaultBasic)
{
MessageBox.Show("The iLogic-Vault method GetNewNumber is not available for Vault Basic", "iLogic-Vault", MessageBoxButtons.OK, MessageBoxIcon.Error);
return null;
}
ACW.NumSchm NmngSchm = null;
try
{
if (mSchmName == "Default")
{
NmngSchm = conn.WebServiceManager.NumberingService.GetNumberingSchemes("FILE", ACW.NumSchmType.Activated).First(n => n.IsDflt == true);
}
else
{
NmngSchm = conn.WebServiceManager.NumberingService.GetNumberingSchemes("FILE", ACW.NumSchmType.Activated).First(n => n.Name == mSchmName);
}
return conn.WebServiceManager.DocumentService.GenerateFileNumber(NmngSchm.SchmID, mSchmPrms);
}
catch (Exception)
{
return null;
}
}
public string CopyLocalFile(string mFullFileName, string mNewNameNoExtension)
{
try
{
System.IO.FileInfo mFileInfo = new System.IO.FileInfo(mFullFileName);
string mExt = mFileInfo.Extension;
string mFileName = mFileInfo.Name;
mFileName = mFileName.Replace(mExt, "");
string mNewFullFileName = mFullFileName.Replace(mFileName, mNewNameNoExtension);
System.IO.File.Copy(mFullFileName, mNewFullFileName, true);
System.IO.FileInfo mNewFileInfo = new System.IO.FileInfo(mNewFullFileName);
return mNewFileInfo.FullName;
}
catch (Exception)
{
return null;
}
}
public string GetThumbnailFileByFullSourceFilePath(string VaultFullFileName, int Width = 300, int Height = 300)
{
string mImageFullFileName = null;
List<string> mFiles = new List<string>();
mFiles.Add(VaultFullFileName);
try
{
ACW.File[] wsFiles = conn.WebServiceManager.DocumentService.FindLatestFilesByPaths(mFiles.ToArray());
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFiles[0]));
Image image = GetThumbnailImage(mFileIt, Width, Height);
if (image != null)
{
string mExt = System.IO.Path.GetExtension(VaultFullFileName);
string LocalFullFileName = conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).ToString();
mImageFullFileName = LocalFullFileName.Replace(mExt, ".jpg");
image.Save(mImageFullFileName);
}
System.IO.FileInfo fileInfo = new System.IO.FileInfo(mImageFullFileName);
if (fileInfo.Exists)
{
return mImageFullFileName;
}
else { return null; }
}
catch (Exception)
{
return null;
}
}
public string GetThumbnailFileBySearchCriteria(Dictionary<string, string> SearchCriteria, bool MatchAllCriteria = true, string[] FoldersSearched = null, int Width = 300, int Height = 300)
{
ACW.Folder[] mFldr;
List<long> mFolders = new List<long>();
if (FoldersSearched != null)
{
mFldr = conn.WebServiceManager.DocumentService.FindFoldersByPaths(FoldersSearched);
foreach (ACW.Folder folder in mFldr)
{
if (folder.Id != -1) mFolders.Add(folder.Id);
}
}
List<String> mFilesFound = new List<string>();
List<ACW.SrchCond> mSrchConds = CreateSrchConds(SearchCriteria, MatchAllCriteria);
List<ACW.File> totalResults = new List<ACW.File>();
string bookmark = string.Empty;
ACW.SrchStatus status = null;
while (status == null || totalResults.Count < status.TotalHits)
{
ACW.File[] mSrchResults = conn.WebServiceManager.DocumentService.FindFilesBySearchConditions(
mSrchConds.ToArray(), null, mFolders.ToArray(), true, true, ref bookmark, out status);
if (mSrchResults != null) totalResults.AddRange(mSrchResults);
else break;
}
if (totalResults.Count >= 1)
{
try
{
string mImageFullFileName = null;
ACW.File wsFile = totalResults.First<ACW.File>();
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFile));
Image image = GetThumbnailImage(mFileIt, Height, Width);
if (image != null)
{
ACW.Folder mParentFldr = conn.WebServiceManager.DocumentService.GetFolderById(wsFile.FolderId);
string VaultFullFileName = mParentFldr.FullName + "/" + wsFile.Name;
string mExt = System.IO.Path.GetExtension(VaultFullFileName);
string LocalFullFileName = conn.WorkingFoldersManager.GetPathOfFileInWorkingFolder(mFileIt).ToString();
mImageFullFileName = LocalFullFileName.Replace(mExt, ".jpg");
image.Save(mImageFullFileName);
}
System.IO.FileInfo fileInfo = new System.IO.FileInfo(mImageFullFileName);
if (fileInfo.Exists)
{
return mImageFullFileName;
}
else { return null; }
}
catch (Exception)
{
return null;
}
}
return null;
}
public Image GetThumbnailImageByFullSourceFilePath(string VaultFullFileName, int Width = 300, int Height = 300)
{
List<string> mFiles = new List<string>();
mFiles.Add(VaultFullFileName);
try
{
ACW.File[] wsFiles = conn.WebServiceManager.DocumentService.FindLatestFilesByPaths(mFiles.ToArray());
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFiles[0]));
Image image = GetThumbnailImage(mFileIt, Width, Height);
if (image != null)
{
return image;
}
else
{
return null;
}
}
catch (Exception)
{
return null;
}
}
public Image GetThumbnailImageBySearchCriteria(Dictionary<string, string> SearchCriteria, bool MatchAllCriteria = true, string[] FoldersSearched = null, int Width = 300, int Height = 300)
{
ACW.Folder[] mFldr;
List<long> mFolders = new List<long>();
if (FoldersSearched != null)
{
mFldr = conn.WebServiceManager.DocumentService.FindFoldersByPaths(FoldersSearched);
foreach (ACW.Folder folder in mFldr)
{
if (folder.Id != -1) mFolders.Add(folder.Id);
}
}
List<String> mFilesFound = new List<string>();
List<ACW.SrchCond> mSrchConds = CreateSrchConds(SearchCriteria, MatchAllCriteria);
List<ACW.File> totalResults = new List<ACW.File>();
string bookmark = string.Empty;
ACW.SrchStatus status = null;
while (status == null || totalResults.Count < status.TotalHits)
{
ACW.File[] mSrchResults = conn.WebServiceManager.DocumentService.FindFilesBySearchConditions(
mSrchConds.ToArray(), null, mFolders.ToArray(), true, true, ref bookmark, out status);
if (mSrchResults != null) totalResults.AddRange(mSrchResults);
else break;
}
if (totalResults.Count >= 1)
{
try
{
ACW.File wsFile = totalResults.First<ACW.File>();
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFile));
Image image = GetThumbnailImage(mFileIt, Width, Height);
if (image != null)
{
return image;
}
else
{
return null;
}
}
catch (Exception)
{
return null;
}
}
return null;
}
public bool UpdateVaultFileProperties(string VaultFullFileName, Dictionary<string, object> VaultFileProperties, bool GetLatestFile = true)
{
if (IsVaultBasic)
{
MessageBox.Show("The iLogic-Vault method UpdateVaultFileProperties is not available for Vault Basic", "iLogic-Vault", MessageBoxButtons.OK, MessageBoxIcon.Error);
return false;
}
List<string> mFiles = new List<string>();
List<String> mFilesDownloaded = new List<string>();
mFiles.Add(VaultFullFileName);
ACW.File[] wsFiles = conn.WebServiceManager.DocumentService.FindLatestFilesByPaths(mFiles.ToArray());
ACW.File mFile = wsFiles.FirstOrDefault();
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, (wsFiles[0]));
Dictionary<ACW.PropDef, object> mPropDictionary = new Dictionary<ACW.PropDef, object>();
ACW.PropDef propDef = new ACW.PropDef();
ACW.PropDef[] propDefs = conn.WebServiceManager.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
foreach (var item in VaultFileProperties)
{
propDef = propDefs.SingleOrDefault(n => n.DispName == item.Key);
if (propDef != null)
{
if (item.Value.GetType().Name == propDef.Typ.ToString())
{
mPropDictionary.Add(propDef, item.Value);
}
if (item.Value.GetType().Name == "Decimal" && propDef.Typ.ToString()== "Numeric")
{
mPropDictionary.Add(propDef, item.Value.ToString());
}
if (item.Value.GetType().Name == "Boolean" && propDef.Typ.ToString() == "Bool")
{
mPropDictionary.Add(propDef, item.Value);
}
}
}
bool success = mUpdateFileProperties(mFileIt, mPropDictionary);
if (success)
{
if (GetLatestFile == true)
{
string latestFile = GetFileByFullFilePath(VaultFullFileName, false);
}
return true;
}
return false;
}
private List<ACW.SrchCond> CreateSrchConds(Dictionary<string, string> SearchCriteria, bool MatchAllCriteria)
{
ACW.PropDef[] mFilePropDefs = conn.WebServiceManager.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
List<ACW.SrchCond> mSrchConds = new List<ACW.SrchCond>();
int i = 0;
foreach (var item in SearchCriteria)
{
ACW.PropDef mFilePropDef = mFilePropDefs.Single(n => n.DispName == item.Key);
ACW.SrchCond mSearchCond = new ACW.SrchCond();
{
mSearchCond.PropDefId = mFilePropDef.Id;
mSearchCond.PropTyp = ACW.PropertySearchType.SingleProperty;
mSearchCond.SrchOper = 3;
if (MatchAllCriteria) mSearchCond.SrchRule = ACW.SearchRuleType.Must;
else mSearchCond.SrchRule = ACW.SearchRuleType.May;
mSearchCond.SrchTxt = item.Value;
}
mSrchConds.Add(mSearchCond);
i++;
}
return mSrchConds;
}
private VDF.Vault.Settings.AcquireFilesSettings CreateAcquireSettings(bool CheckOut)
{
VDF.Vault.Settings.AcquireFilesSettings settings = new VDF.Vault.Settings.AcquireFilesSettings(conn);
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;
if (IsVaultBasic)
{
settings.OptionsRelationshipGathering.FileRelationshipSettings.VersionGatheringOption = VDF.Vault.Currency.VersionGatheringOption.Actual;
}
else
{
settings.OptionsRelationshipGathering.FileRelationshipSettings.ReleaseBiased = true;
settings.OptionsRelationshipGathering.FileRelationshipSettings.VersionGatheringOption = VDF.Vault.Currency.VersionGatheringOption.Revision;
}
settings.OptionsRelationshipGathering.IncludeLinksSettings.IncludeLinks = false;
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;
}
return settings;
}
private VDF.Vault.Currency.Entities.FileIteration CreateFileCopy(ACW.File mSourceFile, string mNewFileName)
{
string mExt = String.Format("{0}{1}", ".", (mSourceFile.Name.Split('.')).Last());
List<long> mIds = new List<long>();
mIds.Add(mSourceFile.Id);
ACW.ByteArray mTicket = conn.WebServiceManager.DocumentService.GetDownloadTicketsByFileIds(mIds.ToArray()).First();
long mTargetFldId = mSourceFile.FolderId;
ACW.PropWriteResults mResults = new ACW.PropWriteResults();
byte[] mUploadTicket = conn.WebServiceManager.FilestoreService.CopyFile(mTicket.Bytes, mExt, true, null, out mResults);
ACW.ByteArray mByteArray = new ACW.ByteArray();
mByteArray.Bytes = mUploadTicket;
ACW.File mNewFile = conn.WebServiceManager.DocumentService.AddUploadedFile(mTargetFldId, mNewFileName, "iLogic File Copy from " + mSourceFile.Name, mSourceFile.ModDate, null, null, mSourceFile.FileClass, false, mByteArray);
VDF.Vault.Currency.Entities.FileIteration mFileIt = new VDF.Vault.Currency.Entities.FileIteration(conn, mNewFile);
return mFileIt;
}
private bool mUpdateFileProperties(ACW.File File, Dictionary<ACW.PropDef, object> PropDictionary)
{
try
{
ACET.IExplorerUtil mExplUtil = ACET.ExplorerLoader.LoadExplorerUtil(
conn.Server, conn.Vault, conn.UserID, conn.Ticket);
mExplUtil.UpdateFileProperties(File, PropDictionary);
return true;
}
catch (Exception)
{
return false;
}
}
private Image GetThumbnailImage(VDF.Vault.Currency.Entities.FileIteration fileIteration, int Width, int Height)
{
try
{
VDF.Vault.Currency.Properties.PropertyDefinitionDictionary mPropDefs = conn.PropertyManager.GetPropertyDefinitions(
VDF.Vault.Currency.Entities.EntityClassIds.Files, null, PropertyDefinitionFilter.IncludeSystem);
VDF.Vault.Currency.Properties.PropertyDefinition mThmbNlPropDef = (mPropDefs.SingleOrDefault(n => n.Key == "Thumbnail").Value);
VDF.Vault.Currency.Properties.PropertyValueSettings mPropSetting = new VDF.Vault.Currency.Properties.PropertyValueSettings();
VDF.Vault.Currency.Properties.ThumbnailInfo mThumbInfo = (VDF.Vault.Currency.Properties.ThumbnailInfo)conn.PropertyManager.GetPropertyValue(fileIteration, mThmbNlPropDef, mPropSetting);
Image image = RenderThumbnailToImage(mThumbInfo, Height, Width);
return image;
}
catch
{
return null;
}
}
private Image GetImage(VDF.Vault.Currency.Properties.ThumbnailInfo value, int width, int height)
{
byte[] thumbnailRaw = (byte[])value.Image;
System.Drawing.Image retVal = null;
using (System.IO.MemoryStream ms = new System.IO.MemoryStream(thumbnailRaw))
{
try
{
ms.Seek(12, System.IO.SeekOrigin.Begin);
System.Drawing.Imaging.Metafile metafile =
new System.Drawing.Imaging.Metafile(ms);
retVal = metafile.GetThumbnailImage(width, height,
new System.Drawing.Image.GetThumbnailImageAbort(GetThumbnailImageAbort),
IntPtr.Zero);
}
catch
{
retVal = null;
}
if (retVal == null)
{
try
{
ms.Seek(0, System.IO.SeekOrigin.Begin);
System.Drawing.Image rawImage = Image.FromStream(ms, true);
retVal = rawImage.GetThumbnailImage(width, height,
new System.Drawing.Image.GetThumbnailImageAbort(GetThumbnailImageAbort),
IntPtr.Zero);
}
catch
{
retVal = null;
}
}
}
return retVal;
}
private static Image RenderThumbnailToImage(VDF.Vault.Currency.Properties.ThumbnailInfo value, int width, int height)
{
byte[] thumbnailRaw = value.Image as byte[];
if (null == thumbnailRaw || 0 == thumbnailRaw.Length)
return null;
Image retImage = null;
using (System.IO.MemoryStream memStream = new System.IO.MemoryStream(thumbnailRaw))
{
using (System.IO.BinaryReader br = new System.IO.BinaryReader(memStream))
{
int CF_METAFILEPICT = 3;
int CF_ENHMETAFILE = 14;
int clipboardFormatId = br.ReadInt32();
bool bytesRepresentMetafile = (clipboardFormatId == CF_METAFILEPICT || clipboardFormatId == CF_ENHMETAFILE);
try
{
if (bytesRepresentMetafile)
{
br.ReadInt16();
br.ReadInt16();
br.ReadInt16();
br.ReadInt16();
System.Drawing.Imaging.Metafile mf = new System.Drawing.Imaging.Metafile(br.BaseStream);
retImage = mf.GetThumbnailImage(width, height, new Image.GetThumbnailImageAbort(GetThumbnailImageAbort), IntPtr.Zero);
}
else
{
memStream.Seek(0, System.IO.SeekOrigin.Begin);
Image im = Image.FromStream(memStream, true, false);
retImage = im.GetThumbnailImage(width, height, new Image.GetThumbnailImageAbort(GetThumbnailImageAbort), IntPtr.Zero);
}
}
catch
{
}
}
}
return retImage;
}
private static bool GetThumbnailImageAbort()
{
return false;
}
private bool IsCadFile(System.IO.FileInfo FileInfo)
{
List<string> mFileExtensions = new List<string> { ".ipt", ".iam", "ipn", ".idw", ".dwg", ".rvt", ".nwd", ".nwc", ".sldprt", ".sldasm", ".slddrw", ".dgn", ".prt", ".asm", ".drw" };
if (mFileExtensions.Any(n => FileInfo.Extension == n))
{
return true;
}
return false;
}
private bool IsFilePath(string path)
{
if (System.IO.File.Exists(path)) return true;
return false;
}
private bool IsDirPath(string path)
{
if (System.IO.Directory.Exists(path)) return true;
return false;
}
private void mGetFileProps(VDF.Vault.Currency.Entities.FileIteration mFileIt, ref Dictionary<string, string> VaultFileProperties)
{
ACW.PropDef[] mPropDefs = conn.WebServiceManager.PropertyService.GetPropertyDefinitionsByEntityClassId("FILE");
ACW.PropInst[] mSourcePropInsts = conn.WebServiceManager.PropertyService.GetPropertiesByEntityIds("FILE", new long[] { mFileIt.EntityIterationId });
string mPropDispName;
string mPropVal;
string mThumbnailDispName = mPropDefs.Where(n => n.SysName == "Thumbnail").FirstOrDefault().DispName;
foreach (ACW.PropInst mFilePropInst in mSourcePropInsts)
{
mPropDispName = mPropDefs.Where(n => n.Id == mFilePropInst.PropDefId).FirstOrDefault().DispName;
if (mPropDispName != mThumbnailDispName)
{
if (mFilePropInst.Val == null)
{
mPropVal = "";
}
else
{
mPropVal = mFilePropInst.Val.ToString();
}
VaultFileProperties.Add(mPropDispName, mPropVal);
}
}
}
private void mGetItemProps(ACW.Item item, ref Dictionary<string, string> VaultItemProperties)
{
string mPropDispName = null;
string mPropVal = null;
string mThumbnailDispName = null;
ACW.PropDef[] mItemPropDefs = conn.WebServiceManager.PropertyService.GetPropertyDefinitionsByEntityClassId("ITEM");
ACW.PropInst[] mItemPropInsts = conn.WebServiceManager.PropertyService.GetPropertiesByEntityIds("ITEM", new long[] { item.Id });
mThumbnailDispName = mItemPropDefs.Where(n => n.SysName == "Thumbnail").FirstOrDefault().DispName;
foreach (ACW.PropInst mItemPropInst in mItemPropInsts)
{
mPropDispName = mItemPropDefs.Where(n => n.Id == mItemPropInst.PropDefId).FirstOrDefault().DispName;
if (mPropDispName != mThumbnailDispName)
{
if (mItemPropInst.Val == null)
{
mPropVal = "";
}
else
{
mPropVal = mItemPropInst.Val.ToString();
}
VaultItemProperties.Add(mPropDispName, mPropVal);
}
}
}
}
}