public static T upload_file <T>(this IObjVerEx obj, string filePath)
where T : IObjVerEx, new()
{
ObjectVersion objVersion = null;
try {
obj.undoObjectCheckoutIfCheckedOut();
objVersion = obj.objVerEx.Vault.ObjectOperations.CheckOut(obj.objVerEx.ObjID);
FileInfo uploadFileInfo = new FileInfo(filePath);
obj.objVerEx.Vault.ObjectFileOperations.AddFile(objVersion.ObjVer,
uploadFileInfo.Name.Replace(uploadFileInfo.Extension, ""),
uploadFileInfo.Extension.Replace(".", ""),
uploadFileInfo.FullName);
obj.objVerEx.Vault.ObjectOperations.CheckIn(objVersion.ObjVer);
return(new T()
{
objVerEx = obj.objVerEx
});
} catch (Exception exception) {
if (objVersion != null &&
obj.objVerEx.Vault.ObjectOperations.IsObjectCheckedOut(objVersion.ObjVer.ObjID, true))
{
obj.objVerEx.Vault.ObjectOperations.CheckIn(objVersion.ObjVer);
}
Console.WriteLine($"Exception during object update: {exception.Message}");
throw;
}
}
public ObjectVersion ClientCaseRetail_Create(BankClient bankClient, BankCaseRetail CaseRetail)
{
ObjectVersion RetValue = new ObjectVersion();
BankClientClass bankClientClass = new BankClientClass();
string PID = bankClient.PersonalID;
ObjectVersion objectVersion = bankClientClass.SearchClientByPersonalID(PID);
if (objectVersion != null)
{
RetValue = objectVersion;
}
else
{
RetValue = bankClientClass.CreateClient(bankClient).ObjectVersion;
}
CaseRetail.Client = Convert.ToInt32(RetValue.DisplayID);
BankCaseRetailClass bankCaseRetailClass = new BankCaseRetailClass();
string mAppID = CaseRetail.ApplicationID;
RetValue = this.CaseRetail_SearchByApplicationID(mAppID);
if (RetValue == null)
{
RetValue = bankCaseRetailClass.CreateCaseRetail(CaseRetail).ObjectVersion;
}
return(RetValue);
}
public static bool create(this ObjVerEx objVerEx, int typeId, int?createdby_mfuserid = null)
{
try {
ObjectVersionAndProperties objVerAndProps =
objVerEx.Vault.ObjectOperations.CreateNewObjectEx(typeId, objVerEx.Properties, null, false, createdby_mfuserid == null);
int objVerID = objVerAndProps.ObjVer.ID;
int objVersion = objVerAndProps.ObjVer.Version;
if (createdby_mfuserid != null)
{
TypedValue created_by = new TypedValue();
created_by.SetValue(MFDataType.MFDatatypeLookup, createdby_mfuserid.Value);
objVerAndProps = objVerEx.Vault.ObjectPropertyOperations.SetCreationInfoAdmin(objVerAndProps.ObjVer, true, created_by, false, null);
ObjectVersion objver = objVerEx.Vault.ObjectOperations.CheckIn(objVerAndProps.ObjVer);
objVerID = objver.ObjVer.ID;
objVersion = objver.ObjVer.Version;
}
objVerEx.ObjVer.ID = objVerID;
objVerEx.ObjVer.Version = objVersion;
objVerEx.ObjVer.Type = objVerAndProps.ObjVer.Type;
return(true);
} catch (Exception exception) {
throw exception;
}
}
public ObjectVersionWrapper(ObjectVersion obj, Vault vault, string vaultName)
{
_objVer = obj;
_vault = new VaultWrapper(vaultName, vault);
VaultName = vaultName;
_propertieValues = new Dictionary <string, PropertyValue>();
}
/// <summary>
/// If there is some questions to be confirmed by the user...
/// </summary>
private static bool UserConfirmations(ObjectVersion version)
{
if (version.Questions != null)
{
foreach (string question in version.Questions)
{
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine();
Console.Write(question);
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" [y/N]: ");
Console.CursorVisible = true;
string response = Console.ReadLine();
Console.CursorVisible = false;
// If the user has answered No, stop now!
if (response == null)
{
return(false);
}
if (!response.ToLower().Equals("y"))
{
return(false);
}
}
}
return(true);
}
// ###################################################################################################################################################################
// ###################################################################################################################################################################
// ###################################################################################################################################################################
//
// Protected\Private Functions
//
// ###################################################################################################################################################################
// ###################################################################################################################################################################
// ###################################################################################################################################################################
// ###################################################################################################################################################################
// Protected Functions
// ###################################################################################################################################################################
/* protected virtual void SetProductInfo(string strProductRoot, string strProductHive, int strProductCipherLength)
* {
* m_strProductRoot = strProductRoot;
* m_strProductHive = strProductHive;
* m_strProductCipherLength = strProductCipherLength;
* m_strProductVersion = Strings.Left(Strings.Replace(ObjectVersion, ".", ""), 3);
* } */
protected virtual void SetProductInfo(string strProductRoot, string strProductHive, int strProductCipherLength)
{
m_strProductRoot = strProductRoot;
m_strProductHive = strProductHive;
m_strProductCipherLength = strProductCipherLength;
m_strProductVersion = ObjectVersion.Replace(".", "").Substring(0, 3);
}
public void GetObjectInfo()
{
Assembly current = Assembly.GetAssembly(typeof(Tools));
Stream stream = current.GetManifestResourceStream(typeof(Tools), "VaultStructure.json");
if (stream == null)
{
Assert.Fail("Failed to load stream.");
}
TestVault vault = TestVault.FromStream(stream);
PropertyValues pvs = new PropertyValues();
PropertyValue pv = new PropertyValue {
PropertyDef = (int)MFBuiltInPropertyDef.MFBuiltInPropertyDefClass
};
pv.TypedValue.SetValue(MFDataType.MFDatatypeLookup, 0);
pvs.Add(-1, pv);
pv.PropertyDef = 0;
pv.TypedValue.SetValue(MFDataType.MFDatatypeText, "Title");
pvs.Add(-1, pv);
ObjectVersionAndProperties ovap = vault.ObjectOperations.CreateNewObject(0, pvs);
ObjectVersion ov = vault.ObjectOperations.GetObjectInfo(ovap.ObjVer, false, true);
Assert.NotNull(ov);
Assert.AreEqual("Title", ov.Title);
}
public void ForceUndoCheckout()
{
Assembly current = Assembly.GetAssembly(typeof(Tools));
Stream stream = current.GetManifestResourceStream(typeof(Tools), "VaultStructure.json");
if (stream == null)
{
Assert.Fail("Failed to load stream.");
}
TestVault vault = TestVault.FromStream(stream);
PropertyValues pvs = new PropertyValues();
PropertyValue pv = new PropertyValue {
PropertyDef = (int)MFBuiltInPropertyDef.MFBuiltInPropertyDefClass
};
pv.TypedValue.SetValue(MFDataType.MFDatatypeLookup, 0);
pvs.Add(-1, pv);
pv.PropertyDef = 0;
pv.TypedValue.SetValue(MFDataType.MFDatatypeText, "Title");
pvs.Add(-1, pv);
ObjectVersionAndProperties ovap = vault.ObjectOperations.CreateNewObject(0, pvs);
Assert.Throws <Exception>(() => vault.ObjectOperations.ForceUndoCheckout(ovap.ObjVer));
ObjectVersion ov = vault.ObjectOperations.CheckOut(ovap.ObjVer.ObjID);
Assert.AreEqual(2, ov.ObjVer.Version);
ov = vault.ObjectOperations.ForceUndoCheckout(ov.ObjVer);
Assert.AreEqual(1, ov.ObjVer.Version);
}
public static void undelete(this IObjVerEx obj)
{
try {
ObjectVersion objVer = obj.objVerEx.Vault.ObjectOperations.UndeleteObject(obj.objVerEx.ObjID);
} catch (Exception exception) {
throw exception;
}
}
public static void replace_files(this OT_Document document, string singledoc_newfilepath = null, string[] multidoc_newfilespath = null)
{
Vault vault = document.objVerEx.Vault;
var obj = document.objVerEx;
bool isSingleFile = vault.ObjectOperations.IsSingleFileObject(obj.ObjVer);
//singlefile document
if (isSingleFile && string.IsNullOrEmpty(singledoc_newfilepath))
{
throw new Exception("No file supplied for single-file document.");
}
//multifile document
if (!isSingleFile && (multidoc_newfilespath == null || multidoc_newfilespath.Length == 0))
{
throw new Exception("No file(s) supplied for multi-file document.");
}
ObjectVersion new_version = vault.ObjectOperations.CheckOut(obj.ObjID);
try {
ObjVerEx new_versionex = new ObjVerEx(vault, new_version);
SourceObjectFiles files = new SourceObjectFiles();
if (isSingleFile)
{
FileInfo fi = new FileInfo(singledoc_newfilepath);
files.AddFile(fi.Name.Replace(fi.Extension, ""), fi.Extension.Replace(".", ""), fi.FullName);
//change the file type
IEnumerator obfile_enumerator = vault.ObjectFileOperations.GetFiles(new_version.ObjVer).GetEnumerator();
obfile_enumerator.MoveNext();
ObjectFile single_fileobj = obfile_enumerator.Current as ObjectFile;
if (single_fileobj == null)
{
throw new Exception("Single file for this document not found.");
}
vault.ObjectFileOperations.RenameFile(new_versionex.ObjVer, single_fileobj.FileVer, fi.Name.Replace(fi.Extension, ""), fi.Extension.Replace(".", ""), false);
}
else
{
foreach (string file in multidoc_newfilespath)
{
FileInfo fi = new FileInfo(file);
files.AddFile(fi.Name.Replace(fi.Extension, ""), fi.Extension.Replace(".", ""), fi.FullName);
}
}
new_versionex.ReplaceFiles(files);
new_versionex.CheckIn();
document.objVerEx = new_versionex;
} catch {
if (new_version.ObjectCheckedOut)
{
vault.ObjectOperations.ForceUndoCheckout(new_version.ObjVer);
}
throw;
}
}
public static void delete(this IObjVerEx obj)
{
try {
obj.undoObjectCheckoutIfCheckedOut();
ObjectVersion objVer = obj.objVerEx.Vault.ObjectOperations.DeleteObject(obj.objVerEx.ObjVer.ObjID);
} catch (Exception exception) {
throw exception;
}
}
public void Initialize(IPluginHost host)
{
_host = host;
searchui_form_id = Name + " " + Version + " " + searchui_form_id;
_version = new ObjectVersion(1, 0);
host.RegisterWindow(this, "Scan/Basic Scanner", searchui_form_id, Description, AddXFormCallback);
}
private static ObjInfo ToObjInfo(ObjectVersion objVn, int level = 0, int parent = -1)
{
return(new ObjInfo(level, parent)
{
ID = objVn.ObjVer.ID,
Type = objVn.ObjVer.Type,
Title = objVn.Title
});
}
public ObjectVersion CaseRetail_Close(int CaseID, int CaseStageID)
{
BankCaseStageClass bankCaseStageClass = new BankCaseStageClass();
ObjectVersion objVer = bankCaseStageClass.UpdateWorkflowState(CaseStageID, 276);
BankCaseRetailClass bankCaseRetailClass = new BankCaseRetailClass();
return(bankCaseRetailClass.UpdateWorkflowState(CaseID, 256));
}
internal static async Task <Result> UploadIfcAsync(Vault vault, string guid, ObjectVersion ifcObj)
{
return(await Task.Run(async() =>
{
var objVer = ifcObj.ObjVer;
var pvs = vault.ObjectPropertyOperations.GetProperties(objVer);
var modelId = GetModel(vault, pvs);
if (modelId == null)
{
return new Result {
Msg = "没有找到模型！", OK = false
};
}
var url = Host + String.Format("Model/Upload?Guid={0}&TypeId={1}&ObjId={2}", guid, 0, modelId.Value);
var file = ifcObj.Files[1].FileVer;
var filePath = vault.ObjectFileOperations.GetPathInDefaultView(objVer.ObjID, objVer.Version, file.ID,
file.Version);
var fullUrl = url;
var name = Path.GetFileName(filePath);
using (var client = new HttpClient(Handler)
{
Timeout = Timeout
})
{
client.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
using (var content =
new MultipartFormDataContent("Upload----" + DateTime.Now.ToString(CultureInfo.InvariantCulture)))
{
//content.Add(new StringContent("F06470B4-070B-4582-9D95-9AE5EA4F5869"), "guid");
//content.Add(new StringContent("1"), "typeid");
//content.Add(new StringContent("1"), "id");
content.Add(new StreamContent(File.OpenRead(filePath)), "file", name);
using (var message = await client.PostAsync(fullUrl, content))
{
var input = String.Empty;
try
{
input = await message.Content.ReadAsStringAsync();
}
catch
{
}
return new Result {
OK = message.IsSuccessStatusCode, Msg = input
}; //!string.IsNullOrWhiteSpace(input) ? Regex.Match(input, @"http://\w*\.directupload\.net/images/\d*/\w*\.[a-z]{3}").Value : null;
}
}
}
}));
}
public T this[ObjectVersion version]
{
get
{
return(objects[(int)version]);
}
set
{
objects[(int)version] = value;
}
}
public void Dispose(IPluginHost host)
{
form_init_id = null;
_manager = null;
_version = null;
if (_getStatusThread != null)
{
_getStatusThread.Abort();
_getStatusThread = null;
}
}
public ObjectVersion DocEntry_UpdateIsRequiredForArchivist(int caseID, int adminID, int docEntryID, bool isArchivist)
{
ObjectVersion objectVersion = null;
BankCaseRetailClass bankCaseRetailClass = new BankCaseRetailClass();
ObjectVersion ov = bankCaseRetailClass.UpdateCreditAdministrator(caseID, adminID);
if (ov != null)
{
BankDocumentEntryClass bankDocumentEntryClass = new BankDocumentEntryClass();
objectVersion = bankDocumentEntryClass.UpdateIsRequiredForArchivist(docEntryID, isArchivist);
}
return(objectVersion);
}
public void RdfMapper_GetIds()
{
//assemble
var mapper = new RdfMapper(new RdfMapperJsonReader(), MappingDocumentPath, ns2);
var model = new ObjectVersion()
{
Id = 1234
};
//act
IEnumerable <string> ids = mapper.GetIds(model);
//assert
Assert.AreEqual(1, ids.Count());
Assert.IsTrue(ids.Contains(model.Id.ToString()));
}
public void Initialize(IPluginHost host)
{
// Setup unique names for each form
form_init_id = Name + " " + Version + " " + form_init_id;
// Set version
_version = new ObjectVersion(1, 0);
// Create MemMan instance
_manager = new MemMan();
_manager.ProcessExited += (sender, e) => { Ready = false; };
// Register forms with UI
host.RegisterWindow(this, "Attach Process", form_init_id, "Displays a list of processes to attach to.", AddInitForm);
}
public ObjectVersion Client_Create(BankClient bankClient)
{
BankClientClass bankClientClass = new BankClientClass();
string PID = bankClient.PersonalID;
ObjectVersion objectVersion = bankClientClass.SearchClientByPersonalID(PID);
if (objectVersion != null)
{
return(objectVersion);
}
else
{
return(bankClientClass.CreateClient(bankClient).ObjectVersion);
}
}
public void SelectVersionOfConflict(int blockNumber, ObjectVersion left)
{
if (left == ObjectVersion.Merged)
{
throw new ArgumentException("Cannot select the merged version, as it doesn't make sense to set it to itself. This indicates you are doing something wrong.");
}
ObjectList <Block> conflictBlock = GetBlock(blockNumber);
diffResults.Merged.SetText(blockNumber, conflictBlock[left].Text);
conflictBlock.Merged.BlockTypeText = diffResults[left].DisplayText;
if (conflictBlocks.Contains(blockNumber))
{
conflictBlocksHandled.Add(blockNumber);
}
}
public void Initialize(IPluginHost host)
{
_version = new ObjectVersion(1, 0);
// Register Search Methods
host.SearchMethods.Add(this, _equalTo);
host.SearchMethods.Add(this, _notEqualTo);
host.SearchMethods.Add(this, _greaterThan);
host.SearchMethods.Add(this, _greaterThanOrEqual);
host.SearchMethods.Add(this, _lessThan);
host.SearchMethods.Add(this, _lessThanOrEqual);
host.SearchMethods.Add(this, _valueBetween);
// Register Search Types
host.SearchTypes.Add(this, _oneByteS);
host.SearchTypes.Add(this, _oneByteU);
host.SearchTypes.Add(this, _twoByteS);
host.SearchTypes.Add(this, _twoByteU);
host.SearchTypes.Add(this, _fourByteS);
host.SearchTypes.Add(this, _fourByteU);
host.SearchTypes.Add(this, _eightByteS);
host.SearchTypes.Add(this, _eightByteU);
host.SearchTypes.Add(this, _xByteS);
host.SearchTypes.Add(this, _xByteU);
host.SearchTypes.Add(this, _singleFP);
host.SearchTypes.Add(this, _doubleFP);
host.SearchTypes.Add(this, _text);
// Register Type Editors
host.TypeEditors.Add(this, _teSByte);
host.TypeEditors.Add(this, _teByte);
host.TypeEditors.Add(this, _teShort);
host.TypeEditors.Add(this, _teUShort);
host.TypeEditors.Add(this, _teInt);
host.TypeEditors.Add(this, _teUInt);
host.TypeEditors.Add(this, _teLong);
host.TypeEditors.Add(this, _teULong);
host.TypeEditors.Add(this, _teFloat);
host.TypeEditors.Add(this, _teDouble);
host.TypeEditors.Add(this, _teString);
host.TypeEditors.Add(this, _teByteArray);
host.TypeEditors.Add(this, _teSByteArray);
// Register Add Ons
host.AddOns.Add(this, _searchUI);
}
public void Dispose(IPluginHost host)
{
// Clean up
_equalTo = null;
_notEqualTo = null;
_greaterThan = null;
_greaterThanOrEqual = null;
_lessThan = null;
_lessThanOrEqual = null;
_valueBetween = null;
_oneByteS = null;
_oneByteU = null;
_twoByteS = null;
_twoByteU = null;
_fourByteS = null;
_fourByteU = null;
_eightByteS = null;
_eightByteU = null;
_xByteS = null;
_xByteU = null;
_singleFP = null;
_doubleFP = null;
_text = null;
_teSByte = null;
_teByte = null;
_teShort = null;
_teUShort = null;
_teInt = null;
_teUInt = null;
_teLong = null;
_teULong = null;
_teFloat = null;
_teDouble = null;
_teString = null;
_teByteArray = null;
_teSByteArray = null;
_searchUI = null;
_version = null;
}
private void Initialize()
{
if (_inited)
{
return;
}
if (_clientVault)
{
if (!ClientUtils.IsInMf(_filePath))
{
throw new Exception("文件未在云系统中！");
}
if (_vault == null)
{
var obj = ClientUtils.GetObjectFromURL(_filePath);
_vault = obj.Vault;
_obj = obj.VersionData;
}
}
else
{
if (_vault == null)
{
throw new Exception("服务端必须指定文档库");
}
var objID = new ObjID();
objID.SetIDs((int)MFBuiltInObjectType.MFBuiltInObjectTypeDocument, _model.Id);
var objAndProps = _vault.ObjectOperations.GetLatestObjectVersionAndProperties(objID, true);
_obj = objAndProps.VersionData;
}
_name = _obj.Title;
if (_aliases == null)
{
_aliases = VaultAliases.GetAliases(_vault);
}
if (!_aliases.IsValid)
{
throw new Exception("文档库缺少必须的元数据！");
}
_inited = true;
}
private void Select_One_Version_Of_Conflict(ObjectVersion versionToUse, string mergedText)
{
TwoWayDiff diffAlgorithm = new TwoWayDiff();
DiffResult result = diffAlgorithm.PerformDiff("Common Text\nLeft Text\nCommon Text2", "Common Text\nRight Text\nCommon Text2");
Assert.That(result.MergedSuccessfully, Is.False, "Merge should not have been successful");
Assert.That(result.ConflictBlocks.Count, Is.EqualTo(1), "Wrong number of Blocks in conflict");
Assert.That(result.BlockCount, Is.EqualTo(3), "Wrong number of blocks.");
// Use the Left text for the conflict.
result.SelectVersionOfConflict(1, versionToUse);
ReadOnlyCollection <ObjectList <Block> > blocks = result.GetBlocks();
Block left = blocks[0].Left;
Block right = blocks[0].Right;
Block merged = blocks[0].Merged;
CommonTests.CheckBlocksAreNotNull(left, right, merged);
Assert.That(blocks[0].Base, Is.Null, "Base is not null");
CommonTests.AssertAllHaveSameSingleLineOfText(left, right, merged, "Common Text");
left = blocks[1].Left;
right = blocks[1].Right;
merged = blocks[1].Merged;
CommonTests.AssertAllHaveOneLineOfText(left, right, merged);
CommonTests.AssertSingleLineOfTextIneachVersionIsEqualTo(left, right, merged, "Left Text", "Right Text", mergedText);
left = blocks[2].Left;
right = blocks[2].Right;
merged = blocks[2].Merged;
CommonTests.CheckBlocksAreNotNull(left, right, merged);
Assert.That(blocks[0].Base, Is.Null, "Base is not null");
CommonTests.AssertAllHaveSameSingleLineOfText(left, right, merged, "Common Text2");
Assert.That(result.MergedSuccessfully, Is.True, "MergedSucessfully was not set to true after all conflicts handled.");
}
public void RdfMapper_MapTriples_ObjectVersion2()
{
//assemble
var mapper = new RdfMapper(new RdfMapperJsonReader(), MappingDocumentPath, ns2);
var model = new ObjectVersion()
{
Id = 11
};
//act
TripleContainer container = mapper.MapTriples(model);
foreach (TestTriple triple in container.Triples.Select(t => new TestTriple(t)))
{
Debug.WriteLine(triple.ToString());
}
//assert
Assert.AreEqual(ns1 + "objects/11", container.Subject);
}
public static List <ObjVerEx> SearchByPropertyDef <T>(ObjVerEx objVerEx, int property_def, T?value)
where T : struct
{
SearchConditions searchConditions = new SearchConditions();
SearchCondition searchCondition;
searchCondition = new SearchCondition();
searchCondition.Expression.SetPropertyValueExpression(property_def, MFParentChildBehavior.MFParentChildBehaviorNone);
searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeLookup, value);
searchConditions.Add(-1, searchCondition);
searchCondition = new SearchCondition();
searchCondition.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeDeleted);
searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeBoolean, false);
searchConditions.Add(-1, searchCondition);
ObjectSearchResults objectSearchResults =
objVerEx.Vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(searchConditions, MFSearchFlags.MFSearchFlagNone, false);
List <ObjVerEx> searchedOT = null;
if (objectSearchResults != null && objectSearchResults.Count > 0)
{
searchedOT = new List <ObjVerEx>();
IEnumerator searchResultObjVerEnum = objectSearchResults.GetAsObjectVersions().GetEnumerator();
ObjectVersion objectVersion = null;
while (searchResultObjVerEnum.MoveNext())
{
objectVersion = (ObjectVersion)searchResultObjVerEnum.Current;
ObjectVersionAndProperties objVerAndProps =
objVerEx.Vault.ObjectOperations.GetLatestObjectVersionAndProperties(objectVersion.ObjVer.ObjID, true);
ObjVerEx item = new ObjVerEx(objVerEx.Vault, objVerAndProps);
searchedOT.Add(item);
}
}
return(searchedOT);
}
private void Select_One_Version_Of_Conflict(ObjectVersion versionToUse, string mergedText)
{
TwoWayDiff diffAlgorithm = new TwoWayDiff();
DiffResult result = diffAlgorithm.PerformDiff("Common Text\nLeft Text\nCommon Text2", "Common Text\nRight Text\nCommon Text2");
Assert.That(result.MergedSuccessfully, Is.False, "Merge should not have been successful");
Assert.That(result.ConflictBlocks.Count, Is.EqualTo(1), "Wrong number of Blocks in conflict");
Assert.That(result.BlockCount, Is.EqualTo(3), "Wrong number of blocks.");
// Use the Left text for the conflict.
result.SelectVersionOfConflict(1, versionToUse);
ReadOnlyCollection<ObjectList<Block>> blocks = result.GetBlocks();
Block left = blocks[0].Left;
Block right = blocks[0].Right;
Block merged = blocks[0].Merged;
CommonTests.CheckBlocksAreNotNull(left, right, merged);
Assert.That(blocks[0].Base, Is.Null, "Base is not null");
CommonTests.AssertAllHaveSameSingleLineOfText(left, right, merged, "Common Text");
left = blocks[1].Left;
right = blocks[1].Right;
merged = blocks[1].Merged;
CommonTests.AssertAllHaveOneLineOfText(left, right, merged);
CommonTests.AssertSingleLineOfTextIneachVersionIsEqualTo(left, right, merged, "Left Text", "Right Text", mergedText);
left = blocks[2].Left;
right = blocks[2].Right;
merged = blocks[2].Merged;
CommonTests.CheckBlocksAreNotNull(left, right, merged);
Assert.That(blocks[0].Base, Is.Null, "Base is not null");
CommonTests.AssertAllHaveSameSingleLineOfText(left, right, merged, "Common Text2");
Assert.That(result.MergedSuccessfully, Is.True, "MergedSucessfully was not set to true after all conflicts handled.");
}
public void Search()
{
Assembly current = Assembly.GetAssembly(typeof(Tools));
Stream stream = current.GetManifestResourceStream(typeof(Tools), "VaultStructure.json");
if (stream == null)
{
Assert.Fail("Failed to load stream.");
}
TestVault vault = TestVault.FromStream(stream);
PropertyValues pvs = new PropertyValues();
PropertyValue pv = new PropertyValue {
PropertyDef = (int)MFBuiltInPropertyDef.MFBuiltInPropertyDefClass
};
pv.TypedValue.SetValue(MFDataType.MFDatatypeLookup, 0);
pvs.Add(-1, pv);
vault.ObjectOperations.CreateNewObject(0, pvs);
Assert.AreEqual(1, vault.ovaps.Count, "Number of objects != 1");
const int testPropID = 55;
pv = new PropertyValue {
PropertyDef = testPropID
};
const int testLookupID = 77;
Lookups lks = new Lookups();
Lookup lk = new Lookup {
Item = testLookupID, ObjectType = 0
};
lks.Add(-1, lk);
pv.TypedValue.SetValueToMultiSelectLookup(lks);
pvs.Add(-1, pv);
vault.ObjectOperations.CreateNewObject(0, pvs);
Assert.AreEqual(2, vault.ovaps.Count, "Original does not have 2 objects");
SearchCondition c = new SearchCondition();
c.Expression.DataPropertyValuePropertyDef = testPropID;
c.ConditionType = MFConditionType.MFConditionTypeEqual;
c.TypedValue.SetValue(MFDataType.MFDatatypeLookup, testLookupID);
SearchCondition sc = new SearchCondition();
sc.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeDeleted);
sc.ConditionType = MFConditionType.MFConditionTypeEqual;
sc.TypedValue.SetValue(MFDataType.MFDatatypeBoolean, false);
SearchConditions search = new SearchConditions();
search.Add(-1, sc);
search.Add(-1, c);
ObjectSearchResults results = vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(search,
MFSearchFlags.MFSearchFlagDisableRelevancyRanking, false);
Assert.AreEqual(1, results.Count);
ObjectVersion ov = results[1];
Assert.NotNull(ov);
ObjectVersions ovs = results.GetAsObjectVersions();
foreach (ObjectVersion result in ovs)
{
Assert.NotNull(result);
}
vault.ObjectOperations.CreateNewObject(2, pvs);
results = vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(search,
MFSearchFlags.MFSearchFlagDisableRelevancyRanking, false);
Assert.AreEqual(2, results.Count);
sc = new SearchCondition();
sc.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeObjectTypeID);
sc.ConditionType = MFConditionType.MFConditionTypeEqual;
sc.TypedValue.SetValue(MFDataType.MFDatatypeLookup, 0);
search.Add(-1, sc);
results = vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(search,
MFSearchFlags.MFSearchFlagDisableRelevancyRanking, false);
Assert.AreEqual(1, results.Count);
}
private void DestroyObject(ObjectVersion objectVersion)
{
var vault = this.VaultService.Vault.Value;
vault.ObjectOperations.DestroyObject(objectVersion.ObjVer.ObjID, true, -1);
}
public void RdfMapper_MapTriples_ObjectVersion1()
{
//assemble
var mapper = new RdfMapper(new RdfMapperJsonReader(), MappingDocumentPath, ns2);
var model = new ObjectVersion()
{
Id = 11,
Description = "test description",
CreatedDate = new DateTime(2016, 4, 27),
Segmentation = new Segmentation()
{
MethodDescription = "test segmentation method description"
},
ObjectVersionType = new ObjectVersionType()
{
RdfUri = ns4 + "raw_image"
}
};
model.Data.Add(new Data.Model.Data()
{
Id = 21,
OriginalFileName = "test1.dcm",
Extension = ".dcm"
});
model.Data.Add(new Data.Model.Data()
{
Id = 22,
OriginalFileName = "test2.dcm",
Extension = ".dcm"
});
model.AnatomicalRegions.Add(new AnatomicalRegion()
{
Id = 50801,
Name = "Brain"
});
model.AnatomicalRegions.Add(new AnatomicalRegion()
{
Id = 9611,
Name = "Femur"
});
//act
TripleContainer container = mapper.MapTriples(model);
IEnumerable <TestTriple> triples = container.Triples.Select(t => new TestTriple(t));
foreach (TestTriple triple in triples)
{
Debug.WriteLine(triple.ToString());
}
//assert
Assert.AreEqual(ns1 + "objects/11", container.Subject);
Assert.IsFalse(triples.Contains(new TestTriple("", "", "")));
Assert.IsTrue(triples.Contains(new TestTriple(ns1 + "objects/11", RdfMapperConstants.RDF_TYPE, ns3 + "object")));
Assert.IsTrue(triples.Contains(new TestTriple(ns1 + "objects/11", ns3 + "object_id", "11")));
Assert.IsTrue(triples.Contains(new TestTriple(ns1 + "objects/11", ns3 + "object_created_date", "27.04.2016 00:00:00")));
Assert.IsTrue(triples.Contains(new TestTriple(ns1 + "objects/11", ns3 + "object_description", "test description")));
Assert.IsTrue(triples.Contains(new TestTriple(ns1 + "objects/11", ns3 + "object_file", ns1 + "files/21")));
Assert.IsTrue(triples.Contains(new TestTriple(ns1 + "objects/11", ns3 + "object_file", ns1 + "files/22")));
Assert.IsTrue(triples.Contains(new TestTriple(ns1 + "objects/11", ns3 + "object_type", ns4 + "raw_image")));
Assert.IsTrue(triples.Contains(new TestTriple(ns1 + "objects/11", ns3 + "object_segmentation_method_description", "test segmentation method description")));
Assert.IsTrue(triples.Contains(new TestTriple(ns1 + "objects/11", ns3 + "object_anatomical_region", "http://purl.org/obo/owlapi/fma#FMA_50801")));
Assert.IsTrue(triples.Contains(new TestTriple(ns1 + "objects/11", ns3 + "object_anatomical_region", "http://purl.org/obo/owlapi/fma#FMA_9611")));
}
protected virtual void LoadDatabaseObjectTypes(ManagementSession session)
{
while (this.reader.Read())
{
switch (this.reader.NodeType)
{
// only process elements, ignore others
case XmlNodeType.Element:
if (this.reader.Name.Equals(Serialization.ObjectType))
{
if (!this.reader.IsEmptyElement)
{
var objectTypeIdString = this.reader.GetAttribute(Serialization.Id);
if (string.IsNullOrEmpty(objectTypeIdString))
{
throw new Exception("Object type id is missing");
}
var objectTypeId = new Guid(objectTypeIdString);
var objectType = this.database.ObjectFactory.GetObjectTypeForType(objectTypeId);
var canLoad = objectType != null && objectType.IsClass;
var objectIdsString = this.reader.ReadString();
var objectIdStringArray = objectIdsString.Split(Serialization.ObjectsSplitterCharArray);
var objectIds = new ObjectId[objectIdStringArray.Length];
var cacheIds = new ObjectVersion[objectIdStringArray.Length];
for (var i = 0; i < objectIds.Length; i++)
{
var objectIdString = objectIdStringArray[i];
if (canLoad)
{
var objectArray = objectIdString.Split(Serialization.ObjectSplitterCharArray);
var objectId = this.database.ObjectIds.Parse(objectArray[0]);
var cacheId = objectArray.Length > 1 ? new ObjectVersionLong(objectArray[1]) : new ObjectVersionLong(Reference.InitialCacheId);
objectIds[i] = objectId;
cacheIds[i] = cacheId;
this.objectTypeByObjectId[objectId] = objectType;
this.objectVersionByObjectId[objectId] = cacheId;
}
else
{
this.OnObjectNotLoaded(objectTypeId, objectIdString);
}
}
if (canLoad)
{
session.LoadObjects(objectType, objectIds);
}
}
}
else
{
throw new Exception("Unknown child element <" + this.reader.Name + "> in parent element <" + Serialization.Database + ">");
}
break;
case XmlNodeType.EndElement:
if (!this.reader.Name.Equals(Serialization.Database))
{
throw new Exception("Expected closing element </" + Serialization.Database + ">");
}
return;
}
}
}
