public void SchemaEditor_RemovePropertyType_WrongContext()
{
//-- hiba: hibas context
SchemaEditor editor = new SchemaEditor();
NodeType nt = editor.CreateNodeType(null, "nt");
PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0);
editor.AddPropertyTypeToPropertySet(slot, nt);
SchemaEditor editor1 = new SchemaEditor();
nt = editor1.CreateNodeType(null, "nt");
slot = editor1.CreatePropertyType("slot", DataType.String, 0);
editor1.AddPropertyTypeToPropertySet(slot, nt);
editor.RemovePropertyTypeFromPropertySet(editor1.PropertyTypes["slot"], editor1.NodeTypes["nt"]);
}
public void SchemaEditor_CreatePropertyType_WrongPropertySlotContext()
{
//-- hiba: rossz context (PropertySlot)
SchemaEditor editor1 = new SchemaEditor();
SchemaEditor editor2 = new SchemaEditor();
editor1.CreatePropertyType("slot", DataType.String);
editor1.CreateNodeType(null, "nt");
editor2.CreatePropertyType("slot", DataType.String);
editor2.CreateNodeType(null, "nt");
NodeType owner = editor1.NodeTypes["nt"];
PropertyType slot = editor2.PropertyTypes["slot"];
editor1.AddPropertyTypeToPropertySet(slot, owner);
}
public void SchemaEditor_AddPropertyToNodeType()
{
SchemaEditor editor = new SchemaEditor();
PropertyType pt1 = editor.CreatePropertyType("PT1", DataType.String);
NodeType nt1 = editor.CreateNodeType(null, "NT1", "T1");
NodeType nt2 = editor.CreateNodeType(nt1, "NT2", "T2");
NodeType nt3 = editor.CreateNodeType(nt2, "NT3", "T3");
editor.AddPropertyTypeToPropertySet(pt1, nt2);
Assert.IsNull(nt1.PropertyTypes["PT1"]);
Assert.IsNull(nt1.DeclaredPropertyTypes["PT1"]);
Assert.IsTrue(Object.ReferenceEquals(nt2.PropertyTypes["PT1"], pt1));
Assert.IsTrue(Object.ReferenceEquals(nt2.DeclaredPropertyTypes["PT1"], pt1));
Assert.IsTrue(Object.ReferenceEquals(nt3.PropertyTypes["PT1"], pt1));
Assert.IsNull(nt3.DeclaredPropertyTypes["PT1"]);
}
public void SchemaEditor_LoadSchema()
{
Test(() =>
{
SchemaEditor editor1 = new SchemaEditor();
editor1.Load();
editor1.CreatePropertyType("NewProperty", DataType.String); //.CreatePermissionType("PermA");
string s = editor1.ToXml();
XmlDocument xd = new XmlDocument();
xd.LoadXml(s);
SchemaEditor editor2 = new SchemaEditor();
editor2.Load(xd);
string ss = editor2.ToXml();
});
}
public void SchemaEditor_RemovePropertyType_Inherited()
{
SchemaEditor editor = new SchemaEditor();
NodeType nt1 = editor.CreateNodeType(null, "nt1", "t1");
NodeType nt2 = editor.CreateNodeType(nt1, "nt2", "t2");
PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0);
editor.AddPropertyTypeToPropertySet(slot, nt1);
PropertyType pt2 = nt2.PropertyTypes["slot"];
editor.RemovePropertyTypeFromPropertySet(pt2, nt2);
Assert.IsNotNull(nt1.PropertyTypes["slot"], "#1");
Assert.IsNotNull(nt2.PropertyTypes["slot"], "#2");
Assert.IsNotNull(nt1.DeclaredPropertyTypes["slot"], "#3");
Assert.IsNull(nt2.DeclaredPropertyTypes["slot"], "#4");
}
public void SchEd_WriterCalling_CreatePropertyType()
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- edit
ed2.CreatePropertyType("PT1", DataType.String);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string log = wr.Log.Replace("\r\n", "");
Assert.IsTrue(log == "Open();CreatePropertyType(name=<PT1>, dataType=<String>, mapping=<0>, isContentListProperty=<False>);Close();");
}
public void SchemaWriter_RemovePropertyTypeFromNodeType()
{
IntegrationTest(() =>
{
var ed = new SchemaEditor();
ed.Load();
var nt = ed.CreateNodeType(null, "NT1-" + Guid.NewGuid(), "ClassName1");
var pt0 = ed.CreatePropertyType("PT0-" + Guid.NewGuid(), DataType.String, GetNextMapping(ed, false));
var pt1 = ed.CreatePropertyType("PT1-" + Guid.NewGuid(), DataType.String, GetNextMapping(ed, false));
var pt2 = ed.CreatePropertyType("PT2-" + Guid.NewGuid(), DataType.String, GetNextMapping(ed, false));
var pt3 = ed.CreatePropertyType("PT3-" + Guid.NewGuid(), DataType.String, GetNextMapping(ed, false));
var pt4 = ed.CreatePropertyType("PT4-" + Guid.NewGuid(), DataType.String, GetNextMapping(ed, false));
nt.AddPropertyType(pt0);
nt.AddPropertyType(pt1);
nt.AddPropertyType(pt2);
nt.AddPropertyType(pt3);
nt.AddPropertyType(pt4);
ed.Register();
// ACTION
ed = new SchemaEditor();
ed.Load();
nt = ed.NodeTypes[nt.Name];
pt0 = ed.PropertyTypes[pt0.Name];
pt1 = ed.PropertyTypes[pt1.Name];
pt2 = ed.PropertyTypes[pt2.Name];
pt3 = ed.PropertyTypes[pt3.Name];
pt4 = ed.PropertyTypes[pt4.Name];
var ptX = ed.CreatePropertyType("PTX-" + Guid.NewGuid(), DataType.String, GetNextMapping(ed, false));
ed.RemovePropertyTypeFromPropertySet(pt4, nt); // last
ed.RemovePropertyTypeFromPropertySet(pt2, nt); // middle
ed.RemovePropertyTypeFromPropertySet(pt0, nt); // first
ed.RemovePropertyTypeFromPropertySet(pt0, nt); // first
ed.RemovePropertyTypeFromPropertySet(ptX, nt); // not a member (without error)
ed.Register();
// ASSERT
var schema = DP.LoadSchemaAsync(CancellationToken.None).GetAwaiter().GetResult();
var ltData = schema.NodeTypes.First(x => x.Name == nt.Name);
AssertSequenceEqual(new[] { pt1.Name, pt3.Name }, ltData.Properties);
});
}
public void SchEd_WriterCalling_ReCreateNodeType()
{
Test(() =>
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
ed1.CreatePropertyType("PT1", DataType.String);
SetSchemaItemId(ed1.PropertyTypes["PT1"], 1);
ed1.CreateNodeType(null, "NT1", "T1");
SetSchemaItemId(ed1.NodeTypes["NT1"], 1);
ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT1"], ed1.NodeTypes["NT1"]);
//-- create current
ed2.CreatePropertyType("PT1", DataType.String);
SetSchemaItemId(ed2.PropertyTypes["PT1"], 1);
ed2.CreateNodeType(null, "NT1", "T1");
SetSchemaItemId(ed2.NodeTypes["NT1"], 1);
ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]);
//-- edit
ed2.DeleteNodeType(ed2.NodeTypes["NT1"]);
ed2.CreateNodeType(null, "NT1", "T1");
ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string expectedLog = @"
Open();
DeleteNodeType(nodeType=<NT1>);
CreateNodeType(parent=<[null]>, name=<NT1>, className=<T1>);
AddPropertyTypeToPropertySet(propertyType=<PT1>, owner=<NT1>, isDeclared=<True>);
Close();
" .Replace("\r\n", "").Replace("\t", "").Replace(" ", "");
string log = wr.Log.Replace("\r\n", "").Replace(" ", "");
Assert.IsTrue(log == expectedLog);
});
}
public PropertyType EnsurePropertyType(string name, DataType dataType)
{
if (_editor == null)
{
_editor = new SchemaEditor();
}
var existing = PropertyTypes.FirstOrDefault(x => x.Name == name);
if (existing != null)
{
if (existing.DataType != dataType)
{
throw new ApplicationException($"DataType mismatch {existing.DataType} <-> {dataType}. PropertyType name: {name}, ");
}
return(existing);
}
var pt = _editor.CreatePropertyType(name, dataType);
PropertyTypes.Add(pt);
return(pt);
}
public void SchemaWriter_AddPropertyTypeToNodeType_Inherited()
{
//Assert.Inconclusive();
IntegrationTest(() =>
{
var ed = new SchemaEditor();
ed.Load();
var nodeTypeName1 = "NT1-" + Guid.NewGuid();
var nodeTypeName2 = "NT2-" + Guid.NewGuid();
var ptName1 = "PT1-" + Guid.NewGuid();
var ptName2 = "PT2-" + Guid.NewGuid();
var nt1 = ed.CreateNodeType(null, nodeTypeName1, "NT0Class");
var ___ = ed.CreateNodeType(nt1, nodeTypeName2, "NT1Class");
var pt1 = ed.CreatePropertyType(ptName1, DataType.String, GetNextMapping(ed, false));
nt1.AddPropertyType(pt1);
ed.Register();
// ASSERT-BEFORE
Assert.AreEqual(1, StorageSchema.NodeTypes[nodeTypeName2].PropertyTypes.Count);
var schema = DP.LoadSchemaAsync(CancellationToken.None).GetAwaiter().GetResult();
var ntData2 = schema.NodeTypes.First(x => x.Name == nodeTypeName2);
Assert.AreEqual(0, ntData2.Properties.Count);
// ACTION
ed = new SchemaEditor();
ed.Load();
var nt2 = ed.NodeTypes[nodeTypeName2];
pt1 = ed.PropertyTypes[ptName1];
nt2.AddPropertyType(pt1);
ed.Register();
// ASSERT-AFTER
Assert.AreEqual(1, StorageSchema.NodeTypes[nodeTypeName2].PropertyTypes.Count);
schema = DP.LoadSchemaAsync(CancellationToken.None).GetAwaiter().GetResult();
ntData2 = schema.NodeTypes.First(x => x.Name == nodeTypeName2);
Assert.AreEqual(1, ntData2.Properties.Count);
});
}
public void SchEd_WriterCalling_DeletePropertyType()
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
ed1.CreatePropertyType("PT1", DataType.String);
SetSchemaItemId(ed1.PropertyTypes["PT1"], 1);
//-- create current
ed2.CreatePropertyType("PT1", DataType.String);
SetSchemaItemId(ed2.PropertyTypes["PT1"], 1);
//-- edit
ed2.DeletePropertyType(ed2.PropertyTypes["PT1"]);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string log = wr.Log.Replace("\r\n", "");
Assert.IsTrue(log == "Open();DeletePropertyType(propertyType=<PT1>);Close();");
}
public void SchemaEditor_CreatePropertySlot()
{
//--
SchemaEditor editor = new SchemaEditor();
PropertyType slot = editor.CreatePropertyType("NewSlot1", DataType.String, 1);
Assert.IsTrue(slot.Id == 0, "Id was not 0");
}
public void SchemaEditor_RemoveAncestorOfOverriddenPropertyFromNodeType()
{
SchemaEditor editor = new SchemaEditor();
PropertyType pt1 = editor.CreatePropertyType("PT1", DataType.String);
NodeType nt1 = editor.CreateNodeType(null, "NT1");
NodeType nt2 = editor.CreateNodeType(nt1, "NT2");
NodeType nt3 = editor.CreateNodeType(nt2, "NT3");
NodeType nt4 = editor.CreateNodeType(nt3, "NT4");
NodeType nt5 = editor.CreateNodeType(nt4, "NT5");
editor.AddPropertyTypeToPropertySet(pt1, nt4);
editor.AddPropertyTypeToPropertySet(pt1, nt2);
editor.RemovePropertyTypeFromPropertySet(pt1, nt2);
Assert.IsNull(nt1.PropertyTypes["PT1"], "#1");
Assert.IsNull(nt2.PropertyTypes["PT1"], "#2");
Assert.IsNull(nt3.PropertyTypes["PT1"], "#3");
Assert.IsNotNull(nt4.PropertyTypes["PT1"], "#4");
Assert.IsNotNull(nt5.PropertyTypes["PT1"], "#5");
Assert.IsNull(nt1.DeclaredPropertyTypes["PT1"], "#6");
Assert.IsNull(nt2.DeclaredPropertyTypes["PT1"], "#7");
Assert.IsNull(nt3.DeclaredPropertyTypes["PT1"], "#8");
Assert.IsNotNull(nt4.DeclaredPropertyTypes["PT1"], "#9");
Assert.IsNull(nt5.DeclaredPropertyTypes["PT1"], "#10");
}
public void SchemaEditor_CreatePropertySlot_WithTheSameName()
{
//-- hiba: nevutkozes
SchemaEditor editor = new SchemaEditor();
PropertyType slot1 = editor.CreatePropertyType("NewSlot", DataType.String);
PropertyType slot2 = editor.CreatePropertyType("NewSlot", DataType.String);
}
public void SchemaEditor_CreatePropertySlot_WithTheSameMapping()
{
//-- hiba: mapping utkozes
SchemaEditor editor = new SchemaEditor();
PropertyType slot1 = editor.CreatePropertyType("NewSlot1", DataType.String, 0);
PropertyType slot2 = editor.CreatePropertyType("NewSlot2", DataType.String, 0);
}
public void SchEd_WriterCalling_CreatePropertyType()
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- edit
ed2.CreatePropertyType("PT1", DataType.String);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string log = wr.Log.Replace("\r\n", "");
Assert.IsTrue(log == "Open();CreatePropertyType(name=<PT1>, dataType=<String>, mapping=<0>, isContentListProperty=<False>);Close();");
}
public void SchemaEditor_RemovePropertyType_FromTopReDeclarerType()
{
SchemaEditor editor = new SchemaEditor();
NodeType nt1 = editor.CreateNodeType(null, "nt1");
NodeType nt2 = editor.CreateNodeType(nt1, "nt2");
NodeType nt3 = editor.CreateNodeType(nt2, "nt3");
PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0);
editor.AddPropertyTypeToPropertySet(slot, nt2);
editor.AddPropertyTypeToPropertySet(slot, nt1);
//-- meg kell jelenjen mindharmon
PropertyType pt1 = nt1.PropertyTypes["slot"];
PropertyType pt2 = nt2.PropertyTypes["slot"];
PropertyType pt3 = nt3.PropertyTypes["slot"];
//-- toroljuk a deklaralas eredeti helyerol
PropertyType pt = editor.PropertyTypes["slot"];
editor.RemovePropertyTypeFromPropertySet(pt, nt1);
//-- el kell tunjon mindkettorol
pt1 = nt1.PropertyTypes["slot"];
pt2 = nt2.PropertyTypes["slot"];
pt3 = nt3.PropertyTypes["slot"];
Assert.IsNull(nt1.PropertyTypes["slot"], "#1");
Assert.IsNotNull(nt2.PropertyTypes["slot"], "#2");
Assert.IsNotNull(nt3.PropertyTypes["slot"], "#3");
}
public void SchemaEditor_ModifyPropertySlot_RemoveProtected()
{
//-- vedett elem torlese
SchemaEditor editor = new SchemaEditor();
PropertyType slot = editor.CreatePropertyType("slot1", DataType.String, 0);
NodeType nt = editor.CreateNodeType(null, "NodeType1", "class");
editor.AddPropertyTypeToPropertySet(slot, nt);
editor.DeletePropertyType(slot);
}
public void SchemaEditor_RemovePropertySlot_WrongContext()
{
//-- hiba: rossz context (ket SchemaEditor)
SchemaEditor editor1 = new SchemaEditor();
SchemaEditor editor2 = new SchemaEditor();
editor1.CreatePropertyType("slot", DataType.String, 0);
editor2.CreatePropertyType("slot", DataType.String, 1);
PropertyType slot = editor1.PropertyTypes["slot"];
editor2.DeletePropertyType(slot);
}
public void SearchOrder_Constructor_SlotAndDirectionDesc()
{
SchemaEditor ed = new SchemaEditor();
PropertyType slot = ed.CreatePropertyType("slot", DataType.String);
SearchOrder target = new SearchOrder(slot, OrderDirection.Desc);
//SearchOrderAccessor acc = new SearchOrderAccessor(target);
Assert.IsTrue(target.Direction == OrderDirection.Desc, "#1");
Assert.IsTrue(target.PropertyToOrder.IsSlot == true, "#2");
Assert.IsTrue(Object.ReferenceEquals(target.PropertyToOrder.PropertySlot, slot), "#3");
}
private PropertyType CreatePropertyType(SchemaEditor editor, string name, DataType dataType, int id)
{
PropertyType pt = editor.CreatePropertyType(name, dataType);
SetSchemaItemId(pt, id);
return pt;
}
public void SchemaEditor_RemovePropertySlot()
{
SchemaEditor editor = new SchemaEditor();
PropertyType slot = editor.CreatePropertyType("slot1", DataType.String, 0);
NodeType nt = editor.CreateNodeType(null, "NodeType1", "class");
editor.AddPropertyTypeToPropertySet(slot, nt);
slot = editor.PropertyTypes["slot1"];
editor.DeletePropertyType(slot);
}
public void SchemaEditor_AddPropertyToNodeType()
{
SchemaEditor editor = new SchemaEditor();
PropertyType pt1 = editor.CreatePropertyType("PT1", DataType.String);
NodeType nt1 = editor.CreateNodeType(null, "NT1");
NodeType nt2 = editor.CreateNodeType(nt1, "NT2");
NodeType nt3 = editor.CreateNodeType(nt2, "NT3");
editor.AddPropertyTypeToPropertySet(pt1, nt2);
Assert.IsNull(nt1.PropertyTypes["PT1"]);
Assert.IsNull(nt1.DeclaredPropertyTypes["PT1"]);
Assert.IsTrue(Object.ReferenceEquals(nt2.PropertyTypes["PT1"], pt1));
Assert.IsTrue(Object.ReferenceEquals(nt2.DeclaredPropertyTypes["PT1"], pt1));
Assert.IsTrue(Object.ReferenceEquals(nt3.PropertyTypes["PT1"], pt1));
Assert.IsNull(nt3.DeclaredPropertyTypes["PT1"]);
}
public void SchemaEditor_CreatePropertyType_WrongPropertySlotContext()
{
//-- hiba: rossz context (PropertySlot)
SchemaEditor editor1 = new SchemaEditor();
SchemaEditor editor2 = new SchemaEditor();
editor1.CreatePropertyType("slot", DataType.String);
editor1.CreateNodeType(null, "nt");
editor2.CreatePropertyType("slot", DataType.String);
editor2.CreateNodeType(null, "nt");
NodeType owner = editor1.NodeTypes["nt"];
PropertyType slot = editor2.PropertyTypes["slot"];
editor1.AddPropertyTypeToPropertySet(slot, owner);
}
public void SchemaEditor_RemoveNodeType()
{
SchemaEditor editor = new SchemaEditor();
NodeType nt1 = editor.CreateNodeType(null, "NT1");
NodeType nt2 = editor.CreateNodeType(nt1, "NT2");
NodeType nt3 = editor.CreateNodeType(nt2, "NT3");
PropertyType slot1 = editor.CreatePropertyType("Slot1", DataType.String);
PropertyType slot2 = editor.CreatePropertyType("Slot2", DataType.String);
PropertyType slot3 = editor.CreatePropertyType("Slot3", DataType.String);
editor.AddPropertyTypeToPropertySet(slot1, nt1);
editor.AddPropertyTypeToPropertySet(slot2, nt2);
editor.AddPropertyTypeToPropertySet(slot3, nt3);
editor.DeleteNodeType(editor.NodeTypes["NT2"]);
Assert.IsTrue(editor.NodeTypes.Count == 1, "#1");
}
public void SchemaEditor_CreateNodeType()
{
SchemaEditor editor = new SchemaEditor();
PropertyType slot = editor.CreatePropertyType("slot", DataType.String);
NodeType nt1 = editor.CreateNodeType(null, "NT1");
editor.AddPropertyTypeToPropertySet(slot, nt1);
NodeType nt2 = editor.CreateNodeType(nt1, "NT2");
Assert.IsNotNull(nt2.PropertyTypes["slot"]);
Assert.IsTrue(nt1.Id == 0, "Id was not 0");
}
public void SchEd_WriterCalling_ModifyNodeType_ChangeParent()
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
ed1.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 1);
ed1.CreatePropertyType("PT2", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 2);
ed1.CreatePropertyType("PT3", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 3);
NodeType nt1 = ed1.CreateNodeType(null, "NT1"); SetSchemaItemId(ed1.NodeTypes["NT1"], 1);
NodeType nt2 = ed1.CreateNodeType(null, "NT2"); SetSchemaItemId(ed1.NodeTypes["NT2"], 2);
NodeType nt3 = ed1.CreateNodeType(nt1, "NT3"); SetSchemaItemId(ed1.NodeTypes["NT3"], 3);
ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT1"], ed1.NodeTypes["NT1"]);
ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT2"], ed1.NodeTypes["NT2"]);
ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT3"], ed1.NodeTypes["NT3"]);
//-- create current
ed2.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 1);
ed2.CreatePropertyType("PT2", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 2);
ed2.CreatePropertyType("PT3", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 3);
nt1 = ed2.CreateNodeType(null, "NT1"); SetSchemaItemId(ed2.NodeTypes["NT1"], 1);
nt2 = ed2.CreateNodeType(null, "NT2"); SetSchemaItemId(ed2.NodeTypes["NT2"], 2);
nt3 = ed2.CreateNodeType(nt1, "NT3"); SetSchemaItemId(ed2.NodeTypes["NT3"], 3);
ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]);
ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT2"], ed2.NodeTypes["NT2"]);
ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT3"], ed2.NodeTypes["NT3"]);
//-- edit
ed2.ModifyNodeType(ed2.NodeTypes["NT3"], ed2.NodeTypes["NT2"]);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string expectedLog = @"
Open();
ModifyNodeType(nodeType=<NT3>, parent=<NT2>, className=<>);
RemovePropertyTypeFromPropertySet(propertyType=<PT1>, owner=<NT3>);
AddPropertyTypeToPropertySet(propertyType=<PT2>, owner=<NT3>, isDeclared=<True>);
Close();
".Replace("\r\n", "").Replace("\t", "").Replace(" ", "");
string log = wr.Log.Replace("\r\n", "").Replace(" ", "");
Assert.IsTrue(log == expectedLog, "#1");
Assert.IsNull(nt1.Parent, "#2");
Assert.IsNull(nt2.Parent, "#3");
Assert.IsTrue(nt3.Parent == nt2, "#4");
Assert.IsTrue(nt1.PropertyTypes.Count == 1, "#5");
Assert.IsTrue(nt2.PropertyTypes.Count == 1, "#6");
Assert.IsTrue(nt3.PropertyTypes.Count == 2, "#7");
Assert.IsNotNull(nt1.PropertyTypes["PT1"], "#8");
Assert.IsNotNull(nt2.PropertyTypes["PT2"], "#9");
Assert.IsNotNull(nt3.PropertyTypes["PT3"], "#10");
Assert.IsNull(nt3.PropertyTypes["PT1"], "#11");
Assert.IsNotNull(nt3.PropertyTypes["PT2"], "#12");
}
public void SchemaEditor_AddWrongPropertyToContentListType()
{
SchemaEditor editor = new SchemaEditor();
PropertyType pt1 = editor.CreatePropertyType("PT1", DataType.String);
var lt1 = editor.CreateContentListType("LT1");
editor.AddPropertyTypeToPropertySet(pt1, lt1);
}
public void NodeQuery_BuildFromXml()
{
SchemaEditor editor = new SchemaEditor();
NodeType nodeType1 = editor.CreateNodeType(null, "nodeType1");
NodeType nodeType2 = editor.CreateNodeType(null, "nodeType2");
PropertyType stringSlot1 = editor.CreatePropertyType("stringSlot1", DataType.String);
PropertyType stringSlot2 = editor.CreatePropertyType("stringSlot2", DataType.String);
PropertyType intSlot1 = editor.CreatePropertyType("intSlot1", DataType.Int);
PropertyType intSlot2 = editor.CreatePropertyType("intSlot2", DataType.Int);
PropertyType dateTimeSlot1 = editor.CreatePropertyType("dateTimeSlot1", DataType.DateTime);
PropertyType dateTimeSlot2 = editor.CreatePropertyType("dateTimeSlot2", DataType.DateTime);
PropertyType currencySlot1 = editor.CreatePropertyType("currencySlot1", DataType.Currency);
PropertyType currencySlot2 = editor.CreatePropertyType("currencySlot2", DataType.Currency);
PropertyType refSlot1 = editor.CreatePropertyType("refSlot1", DataType.Reference);
PropertyType refSlot2 = editor.CreatePropertyType("refSlot2", DataType.Reference);
NodeQuery query = new NodeQuery();
//==== Operators
ExpressionList strOpExp = new ExpressionList(ChainOperator.Or);
query.Add(strOpExp);
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.Contains, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.EndsWith, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.Equal, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.GreaterThan, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.GreaterThanOrEqual, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.LessThan, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.LessThanOrEqual, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.NotEqual, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.StartsWith, "{path}"));
//==== StringExpression
ExpressionList strExp = new ExpressionList(ChainOperator.Or);
query.Add(strExp);
strExp.Add(new StringExpression(stringSlot1, StringOperator.Equal, "{value}"));
strExp.Add(new StringExpression(stringSlot1, StringOperator.Equal, stringSlot2));
strExp.Add(new StringExpression(stringSlot1, StringOperator.Equal, StringAttribute.Path));
strExp.Add(new StringExpression(stringSlot1, StringOperator.Equal, (string)null));
strExp.Add(new StringExpression(StringAttribute.Name, StringOperator.Equal, "{value}"));
strExp.Add(new StringExpression(StringAttribute.Name, StringOperator.Equal, stringSlot2));
strExp.Add(new StringExpression(StringAttribute.Name, StringOperator.Equal, StringAttribute.Path));
strExp.Add(new StringExpression(StringAttribute.Name, StringOperator.Equal, (string)null));
//==== IntExpression
ExpressionList intExp = new ExpressionList(ChainOperator.Or);
query.Add(intExp);
intExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.Equal, 123));
intExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.Equal, IntAttribute.MajorVersion));
intExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.Equal, intSlot2));
intExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.Equal, (int?)null));
intExp.Add(new IntExpression(intSlot1, ValueOperator.Equal, 123));
intExp.Add(new IntExpression(intSlot1, ValueOperator.Equal, IntAttribute.MajorVersion));
intExp.Add(new IntExpression(intSlot1, ValueOperator.Equal, intSlot2));
intExp.Add(new IntExpression(intSlot1, ValueOperator.Equal, (int?)null));
//==== DateTimeExpression
ExpressionList dtExp = new ExpressionList(ChainOperator.Or);
query.Add(dtExp);
dtExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.Equal, DateTime.Now));
dtExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.Equal, DateTimeAttribute.ModificationDate));
dtExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.Equal, dateTimeSlot2));
dtExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.Equal, (DateTime?)null));
dtExp.Add(new DateTimeExpression(dateTimeSlot1, ValueOperator.Equal, DateTime.Now));
dtExp.Add(new DateTimeExpression(dateTimeSlot1, ValueOperator.Equal, DateTimeAttribute.ModificationDate));
dtExp.Add(new DateTimeExpression(dateTimeSlot1, ValueOperator.Equal, dateTimeSlot2));
dtExp.Add(new DateTimeExpression(dateTimeSlot1, ValueOperator.Equal, (DateTime?)null));
//==== CurrencyExpression
ExpressionList curExp = new ExpressionList(ChainOperator.Or);
query.Add(curExp);
curExp.Add(new CurrencyExpression(currencySlot1, ValueOperator.Equal, (decimal)123.456));
curExp.Add(new CurrencyExpression(currencySlot1, ValueOperator.Equal, currencySlot2));
curExp.Add(new CurrencyExpression(currencySlot1, ValueOperator.Equal, (decimal?)null));
//==== ReferenceExpression
ExpressionList subExp = new ExpressionList(ChainOperator.And);
subExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.GreaterThan, 123));
subExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.GreaterThan, DateTime.Now));
ExpressionList refExp = new ExpressionList(ChainOperator.Or);
query.Add(refExp);
refExp.Add(new ReferenceExpression(refSlot1));
refExp.Add(new ReferenceExpression(ReferenceAttribute.LockedBy));
refExp.Add(new ReferenceExpression(refSlot1, (Node)null));
refExp.Add(new ReferenceExpression(refSlot1, Repository.Root));
refExp.Add(new ReferenceExpression(ReferenceAttribute.LockedBy, (Node)null));
refExp.Add(new ReferenceExpression(ReferenceAttribute.LockedBy, Repository.Root));
refExp.Add(new ReferenceExpression(refSlot1, subExp));
refExp.Add(new ReferenceExpression(ReferenceAttribute.LockedBy, subExp));
//==== TypeExpression
ExpressionList typeExp = new ExpressionList(ChainOperator.Or);
query.Add(typeExp);
typeExp.Add(new TypeExpression(nodeType1));
typeExp.Add(new TypeExpression(nodeType2, true));
//==== Negation
Expression negExp = new NotExpression(
new ExpressionList(ChainOperator.And,
new StringExpression(StringAttribute.Path, StringOperator.StartsWith, "/Root1/"),
new StringExpression(StringAttribute.Name, StringOperator.NotEqual, "name")
));
query.Add(negExp);
//==== Orders
query.Orders.Add(new SearchOrder(DateTimeAttribute.ModificationDate, OrderDirection.Desc));
query.Orders.Add(new SearchOrder(IntAttribute.MajorVersion, OrderDirection.Asc));
query.Orders.Add(new SearchOrder(StringAttribute.Name, OrderDirection.Asc));
//==== Paging
query.PageSize = 123;
query.StartIndex = 987;
string queryString = query.ToXml();
NodeQueryAccessor queryAcc = new NodeQueryAccessor(new NodeQuery());
NodeQuery newQuery = queryAcc.Parse(queryString, editor);
string newQueryString = newQuery.ToXml();
Assert.IsTrue(queryString != null && queryString == newQueryString);
}
public void SchemaEditor_RemovePropertyType_WrongContext()
{
//-- hiba: hibas context
SchemaEditor editor = new SchemaEditor();
NodeType nt = editor.CreateNodeType(null, "nt");
PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0);
editor.AddPropertyTypeToPropertySet(slot, nt);
SchemaEditor editor1 = new SchemaEditor();
nt = editor1.CreateNodeType(null, "nt");
slot = editor1.CreatePropertyType("slot", DataType.String, 0);
editor1.AddPropertyTypeToPropertySet(slot, nt);
editor.RemovePropertyTypeFromPropertySet(editor1.PropertyTypes["slot"], editor1.NodeTypes["nt"]);
}
public void SchEd_WriterCalling_ReCreateNodeType()
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
ed1.CreatePropertyType("PT1", DataType.String);
SetSchemaItemId(ed1.PropertyTypes["PT1"], 1);
ed1.CreateNodeType(null, "NT1");
SetSchemaItemId(ed1.NodeTypes["NT1"], 1);
ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT1"], ed1.NodeTypes["NT1"]);
//-- create current
ed2.CreatePropertyType("PT1", DataType.String);
SetSchemaItemId(ed2.PropertyTypes["PT1"], 1);
ed2.CreateNodeType(null, "NT1");
SetSchemaItemId(ed2.NodeTypes["NT1"], 1);
ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]);
//-- edit
ed2.DeleteNodeType(ed2.NodeTypes["NT1"]);
ed2.CreateNodeType(null, "NT1");
ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string expectedLog = @"
Open();
DeleteNodeType(nodeType=<NT1>);
CreateNodeType(parent=<[null]>, name=<NT1>, className=<>);
AddPropertyTypeToPropertySet(propertyType=<PT1>, owner=<NT1>, isDeclared=<True>);
Close();
".Replace("\r\n", "").Replace("\t", "").Replace(" ", "");
string log = wr.Log.Replace("\r\n", "").Replace(" ", "");
Assert.IsTrue(log == expectedLog);
}
internal static void ApplyChangesInEditor(ContentType contentType, SchemaEditor editor)
{
// Find ContentHandler
var handlerType = TypeResolver.GetType(contentType.HandlerName, false);
if (handlerType == null)
{
throw new RegistrationException(string.Concat(
SR.Exceptions.Registration.Msg_ContentHandlerNotFound, ": ", contentType.HandlerName));
}
// parent type
NodeType parentNodeType = null;
if (contentType.ParentTypeName != null)
{
parentNodeType = editor.NodeTypes[contentType.ParentTypeName];
if (parentNodeType == null)
{
throw new ContentRegistrationException(SR.Exceptions.Registration.Msg_UnknownParentContentType, contentType.Name);
}
// make sure that all content handlers defined on the parent chain exist
var pnt = parentNodeType;
while (pnt != null)
{
var ht = TypeResolver.GetType(pnt.ClassName, false);
if (ht == null)
{
throw new RegistrationException($"Unknown content handler: {pnt.ClassName}");
}
pnt = pnt.Parent;
}
}
// handler type
NodeType nodeType = editor.NodeTypes[contentType.Name];
if (nodeType == null)
{
nodeType = editor.CreateNodeType(parentNodeType, contentType.Name, contentType.HandlerName);
}
if (nodeType.ClassName != contentType.HandlerName)
{
editor.ModifyNodeType(nodeType, contentType.HandlerName);
}
if (nodeType.Parent != parentNodeType)
{
editor.ModifyNodeType(nodeType, parentNodeType);
}
// 1: ContentHandler properties
NodeTypeRegistration ntReg = ParseAttributes(handlerType);
if (ntReg == null)
{
throw new ContentRegistrationException(
SR.Exceptions.Registration.Msg_DefinedHandlerIsNotAContentHandler, contentType.Name);
}
// 2: Field properties
foreach (FieldSetting fieldSetting in contentType.FieldSettings)
{
Type[][] slots = fieldSetting.HandlerSlots;
int fieldSlotCount = slots.GetLength(0);
if (fieldSetting.Bindings.Count != fieldSlotCount)
{
throw new ContentRegistrationException(String.Format(CultureInfo.InvariantCulture,
SR.Exceptions.Registration.Msg_FieldBindingsCount_1, fieldSlotCount), contentType.Name, fieldSetting.Name);
}
for (int i = 0; i < fieldSetting.Bindings.Count; i++)
{
string propName = fieldSetting.Bindings[i];
var dataType = fieldSetting.DataTypes[i];
CheckDataType(propName, dataType, contentType.Name, editor);
PropertyInfo propInfo = handlerType.GetProperty(propName);
if (propInfo != null)
{
// #1: there is a property under the slot:
bool ok = false;
for (int j = 0; j < slots[i].Length; j++)
{
if (slots[i][j].IsAssignableFrom(propInfo.PropertyType))
{
PropertyTypeRegistration propReg = ntReg.PropertyTypeRegistrationByName(propName);
if (propInfo.DeclaringType != handlerType)
{
if (propReg == null)
{
object[] attrs = propInfo.GetCustomAttributes(typeof(RepositoryPropertyAttribute), false);
if (attrs.Length > 0)
{
propReg = new PropertyTypeRegistration(propInfo, (RepositoryPropertyAttribute)attrs[0]);
ntReg.PropertyTypeRegistrations.Add(propReg);
}
}
}
if (propReg != null && propReg.DataType != fieldSetting.DataTypes[i])
{
throw new ContentRegistrationException(String.Concat(
"The data type of the field in the content type definition does not match the data type of its content handler's property. ",
"Please modify the field type in the content type definition. ",
"ContentTypeDefinition: '", contentType.Name,
"', FieldName: '", fieldSetting.Name,
"', DataType of Field's binding: '", fieldSetting.DataTypes[i],
"', ContentHandler: '", handlerType.FullName,
"', PropertyName: '", propReg.Name,
"', DataType of property: '", propReg.DataType,
"'"));
}
ok = true;
fieldSetting.HandlerSlotIndices[i] = j;
fieldSetting.PropertyIsReadOnly = !PropertyHasPublicSetter(propInfo);
break;
}
}
if (!ok)
{
if (fieldSetting.ShortName == "Reference" || fieldSetting.DataTypes[i] == RepositoryDataType.Reference)
{
CheckReference(propInfo, slots[i], contentType, fieldSetting);
}
else
{
throw new ContentRegistrationException(SR.Exceptions.Registration.Msg_PropertyAndFieldAreNotConnectable,
contentType.Name, fieldSetting.Name);
}
}
}
else
{
// #2: there is not a property under the slot:
PropertyTypeRegistration propReg = new PropertyTypeRegistration(propName, dataType);
ntReg.PropertyTypeRegistrations.Add(propReg);
}
}
}
// Collect deletables. Check equals
foreach (PropertyType propType in nodeType.PropertyTypes.ToArray())
{
PropertyTypeRegistration propReg = ntReg.PropertyTypeRegistrationByName(propType.Name);
if (propReg == null)
{
editor.RemovePropertyTypeFromPropertySet(propType, nodeType);
}
}
// Register
foreach (PropertyTypeRegistration ptReg in ntReg.PropertyTypeRegistrations)
{
PropertyType propType = nodeType.PropertyTypes[ptReg.Name];
if (propType == null)
{
propType = editor.PropertyTypes[ptReg.Name];
if (propType == null)
{
propType = editor.CreatePropertyType(ptReg.Name, ConvertDataType(ptReg.DataType));
}
editor.AddPropertyTypeToPropertySet(propType, nodeType);
}
}
}
//TODO: Change structure: not implemented
//[TestMethod()]
//public void ContentType_FullInstall_InheritedClass_ChangeParent()
//{
// Assembly asm = SchemaTestTools.DynamicAssembly;
// //-- Step 1: Install content types: TestType1, TestType2 and TestType1/TestType3
// string contentTypeDef1 = @"<?xml version='1.0' encoding='utf-8'?>
// <ContentType name='TestType1' parentType='GenericContent' handler='SenseNet.ContentRepository.GenericContent' xmlns='http://schemas.sensenet.com/SenseNet/ContentRepository/ContentTypeDefinition'>
// <Fields>
// <Field name='TestField' type='ShortText'>
// <DisplayName>TestField1</DisplayName>
// </Field>
// </Fields>
// </ContentType>";
// string contentTypeDef2 = @"<?xml version='1.0' encoding='utf-8'?>
// <ContentType name='TestType2' parentType='GenericContent' handler='SenseNet.ContentRepository.GenericContent' xmlns='http://schemas.sensenet.com/SenseNet/ContentRepository/ContentTypeDefinition'>
// <Fields>
// <Field name='TestField' type='ShortText'>
// <DisplayName>TestField2</DisplayName>
// </Field>
// </Fields>
// </ContentType>";
// string contentTypeDef3 = @"<?xml version='1.0' encoding='utf-8'?>
// <ContentType name='TestType3' parentType='TestType1' handler='SenseNet.ContentRepository.GenericContent' xmlns='http://schemas.sensenet.com/SenseNet/ContentRepository/ContentTypeDefinition'>
// <Fields>
// <Field name='TestField' type='ShortText'></Field>
// </Fields>
// </ContentType>";
// ContentTypeInstaller installer = ContentTypeInstaller.CreateBatchContentTypeInstaller();
// installer.AddContentType(contentTypeDef1);
// installer.AddContentType(contentTypeDef2);
// installer.AddContentType(contentTypeDef3);
// installer.ExecuteBatch();
// //-- Step 2: Reinstall TestType3 under TestType2
// contentTypeDef3 = @"<?xml version='1.0' encoding='utf-8'?>
// <ContentType name='TestType3' parentType='TestType2' handler='SenseNet.ContentRepository.GenericContent' xmlns='http://schemas.sensenet.com/SenseNet/ContentRepository/ContentTypeDefinition'></ContentType>";
// ContentTypeInstaller.InstallContentType(contentTypeDef3);
// NodeType nt1 = ActiveSchema.NodeTypes["TestType1"];
// NodeType nt2 = ActiveSchema.NodeTypes["TestType2"];
// NodeType nt3 = ActiveSchema.NodeTypes["TestType3"];
// ContentType ct1 = ContentTypeManager.Current.GetContentTypeByName(nt1.Name);
// ContentType ct2 = ContentTypeManager.Current.GetContentTypeByName(nt2.Name);
// ContentType ct3 = ContentTypeManager.Current.GetContentTypeByName(nt3.Name);
// SNC.Content c3 = SNC.Content.CreateNew("TestType3", this.TestRoot, "ChangeParentTest3");
// Assert.IsTrue(ct3.Path == Path.Combine(ct2.Path, ct3.Name));
// Assert.IsTrue(c3.Fields["TestField"].Title == "TestField2");
//}
//================================================= Tools =================================================
private string InstallContentType(string contentTypeDefInstall, string contentTypeDefModify)
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
ContentTypeManagerAccessor ctmAcc = new ContentTypeManagerAccessor(ContentTypeManager.Current);
ContentType cts = ctmAcc.LoadOrCreateNew(contentTypeDefInstall);
if (contentTypeDefModify != null)
{
cts.Save(false);
var parent = ContentType.GetByName(cts.ParentName);
ContentTypeManager.Current.AddContentType(cts);
}
ctmAcc.ApplyChangesInEditor(cts, ed2);
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
ed2Acc.RegisterSchema(ed1, wr);
if (contentTypeDefModify != null)
{
//-- Id-k beallitasa es klonozas
SchemaEditor ed3 = new SchemaEditor();
SchemaEditorAccessor ed3Acc = new SchemaEditorAccessor(ed3);
SchemaItemAccessor schItemAcc;
int id = 1;
foreach (PropertyType pt in ed2.PropertyTypes)
{
PropertyType clone = ed3.CreatePropertyType(pt.Name, pt.DataType, pt.Mapping);
schItemAcc = new SchemaItemAccessor(pt);
schItemAcc.Id = id++;
schItemAcc = new SchemaItemAccessor(clone);
schItemAcc.Id = pt.Id;
}
id = 1;
foreach (NodeType nt in ed2.NodeTypes)
{
NodeType clone = ed3.CreateNodeType(nt.Parent, nt.Name, nt.ClassName);
foreach (PropertyType pt in nt.PropertyTypes)
ed3.AddPropertyTypeToPropertySet(ed3.PropertyTypes[pt.Name], clone);
schItemAcc = new SchemaItemAccessor(nt);
schItemAcc.Id = id++;
schItemAcc = new SchemaItemAccessor(clone);
schItemAcc.Id = nt.Id;
}
cts = ctmAcc.LoadOrCreateNew(contentTypeDefModify);
ctmAcc.ApplyChangesInEditor(cts, ed3);
wr = new TestSchemaWriter();
ed3Acc.RegisterSchema(ed2, wr);
}
return wr.Log;
}
public void SchEd_WriterCalling_ModifyNodeType()
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
ed1.CreatePropertyType("PT1", DataType.String);
SetSchemaItemId(ed1.PropertyTypes["PT1"], 1);
ed1.CreateNodeType(null, "NT1");
SetSchemaItemId(ed1.NodeTypes["NT1"], 1);
ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT1"], ed1.NodeTypes["NT1"]);
//-- create current
ed2.CreatePropertyType("PT1", DataType.String);
SetSchemaItemId(ed2.PropertyTypes["PT1"], 1);
ed2.CreateNodeType(null, "NT1");
SetSchemaItemId(ed2.NodeTypes["NT1"], 1);
ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]);
//-- edit
ed2.ModifyNodeType(ed2.NodeTypes["NT1"], "ClassName2");
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string log = wr.Log.Replace("\r\n", "");
Assert.IsTrue(log == "Open();ModifyNodeType(nodeType=<NT1>, parent=<[null]>, className=<ClassName2>);Close();");
}
public void SchemaEditor_RemovePropertyType_NullPropertyType()
{
//---- hiba: Target item cannot be null
SchemaEditor editor = new SchemaEditor();
NodeType nt = editor.CreateNodeType(null, "nt");
PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0);
editor.AddPropertyTypeToPropertySet(slot, nt);
new SchemaEditor().RemovePropertyTypeFromPropertySet(slot, null);
}
public void NodeQuery_BuildFromXml()
{
SchemaEditor editor = new SchemaEditor();
NodeType nodeType1 = editor.CreateNodeType(null, "nodeType1");
NodeType nodeType2 = editor.CreateNodeType(null, "nodeType2");
PropertyType stringSlot1 = editor.CreatePropertyType("stringSlot1", DataType.String);
PropertyType stringSlot2 = editor.CreatePropertyType("stringSlot2", DataType.String);
PropertyType intSlot1 = editor.CreatePropertyType("intSlot1", DataType.Int);
PropertyType intSlot2 = editor.CreatePropertyType("intSlot2", DataType.Int);
PropertyType dateTimeSlot1 = editor.CreatePropertyType("dateTimeSlot1", DataType.DateTime);
PropertyType dateTimeSlot2 = editor.CreatePropertyType("dateTimeSlot2", DataType.DateTime);
PropertyType currencySlot1 = editor.CreatePropertyType("currencySlot1", DataType.Currency);
PropertyType currencySlot2 = editor.CreatePropertyType("currencySlot2", DataType.Currency);
PropertyType refSlot1 = editor.CreatePropertyType("refSlot1", DataType.Reference);
PropertyType refSlot2 = editor.CreatePropertyType("refSlot2", DataType.Reference);
NodeQuery query = new NodeQuery();
//==== Operators
ExpressionList strOpExp = new ExpressionList(ChainOperator.Or);
query.Add(strOpExp);
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.Contains, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.EndsWith, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.Equal, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.GreaterThan, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.GreaterThanOrEqual, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.LessThan, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.LessThanOrEqual, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.NotEqual, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.StartsWith, "{path}"));
//==== StringExpression
ExpressionList strExp = new ExpressionList(ChainOperator.Or);
query.Add(strExp);
strExp.Add(new StringExpression(stringSlot1, StringOperator.Equal, "{value}"));
strExp.Add(new StringExpression(stringSlot1, StringOperator.Equal, stringSlot2));
strExp.Add(new StringExpression(stringSlot1, StringOperator.Equal, StringAttribute.Path));
strExp.Add(new StringExpression(stringSlot1, StringOperator.Equal, (string)null));
strExp.Add(new StringExpression(StringAttribute.Name, StringOperator.Equal, "{value}"));
strExp.Add(new StringExpression(StringAttribute.Name, StringOperator.Equal, stringSlot2));
strExp.Add(new StringExpression(StringAttribute.Name, StringOperator.Equal, StringAttribute.Path));
strExp.Add(new StringExpression(StringAttribute.Name, StringOperator.Equal, (string)null));
//==== IntExpression
ExpressionList intExp = new ExpressionList(ChainOperator.Or);
query.Add(intExp);
intExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.Equal, 123));
intExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.Equal, IntAttribute.MajorVersion));
intExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.Equal, intSlot2));
intExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.Equal, (int?)null));
intExp.Add(new IntExpression(intSlot1, ValueOperator.Equal, 123));
intExp.Add(new IntExpression(intSlot1, ValueOperator.Equal, IntAttribute.MajorVersion));
intExp.Add(new IntExpression(intSlot1, ValueOperator.Equal, intSlot2));
intExp.Add(new IntExpression(intSlot1, ValueOperator.Equal, (int?)null));
//==== DateTimeExpression
ExpressionList dtExp = new ExpressionList(ChainOperator.Or);
query.Add(dtExp);
dtExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.Equal, DateTime.Now));
dtExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.Equal, DateTimeAttribute.ModificationDate));
dtExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.Equal, dateTimeSlot2));
dtExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.Equal, (DateTime?)null));
dtExp.Add(new DateTimeExpression(dateTimeSlot1, ValueOperator.Equal, DateTime.Now));
dtExp.Add(new DateTimeExpression(dateTimeSlot1, ValueOperator.Equal, DateTimeAttribute.ModificationDate));
dtExp.Add(new DateTimeExpression(dateTimeSlot1, ValueOperator.Equal, dateTimeSlot2));
dtExp.Add(new DateTimeExpression(dateTimeSlot1, ValueOperator.Equal, (DateTime?)null));
//==== CurrencyExpression
ExpressionList curExp = new ExpressionList(ChainOperator.Or);
query.Add(curExp);
curExp.Add(new CurrencyExpression(currencySlot1, ValueOperator.Equal, (decimal)123.456));
curExp.Add(new CurrencyExpression(currencySlot1, ValueOperator.Equal, currencySlot2));
curExp.Add(new CurrencyExpression(currencySlot1, ValueOperator.Equal, (decimal?)null));
//==== ReferenceExpression
ExpressionList subExp = new ExpressionList(ChainOperator.And);
subExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.GreaterThan, 123));
subExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.GreaterThan, DateTime.Now));
ExpressionList refExp = new ExpressionList(ChainOperator.Or);
query.Add(refExp);
refExp.Add(new ReferenceExpression(refSlot1));
refExp.Add(new ReferenceExpression(ReferenceAttribute.LockedBy));
refExp.Add(new ReferenceExpression(refSlot1, (Node)null));
refExp.Add(new ReferenceExpression(refSlot1, Repository.Root));
refExp.Add(new ReferenceExpression(ReferenceAttribute.LockedBy, (Node)null));
refExp.Add(new ReferenceExpression(ReferenceAttribute.LockedBy, Repository.Root));
refExp.Add(new ReferenceExpression(refSlot1, subExp));
refExp.Add(new ReferenceExpression(ReferenceAttribute.LockedBy, subExp));
//==== TypeExpression
ExpressionList typeExp = new ExpressionList(ChainOperator.Or);
query.Add(typeExp);
typeExp.Add(new TypeExpression(nodeType1));
typeExp.Add(new TypeExpression(nodeType2, true));
//==== Negation
Expression negExp = new NotExpression(
new ExpressionList(ChainOperator.And,
new StringExpression(StringAttribute.Path, StringOperator.StartsWith, "/Root1/"),
new StringExpression(StringAttribute.Name, StringOperator.NotEqual, "name")
));
query.Add(negExp);
//==== Orders
query.Orders.Add(new SearchOrder(DateTimeAttribute.ModificationDate, OrderDirection.Desc));
query.Orders.Add(new SearchOrder(IntAttribute.MajorVersion, OrderDirection.Asc));
query.Orders.Add(new SearchOrder(StringAttribute.Name, OrderDirection.Asc));
//==== Paging
query.PageSize = 123;
query.StartIndex = 987;
string queryString = query.ToXml();
NodeQueryAccessor queryAcc = new NodeQueryAccessor(new NodeQuery());
NodeQuery newQuery = queryAcc.Parse(queryString, editor);
string newQueryString = newQuery.ToXml();
Assert.IsTrue(queryString != null && queryString == newQueryString);
}
public void SchemaEditor_RemovePropertyType_Inherited()
{
SchemaEditor editor = new SchemaEditor();
NodeType nt1 = editor.CreateNodeType(null, "nt1");
NodeType nt2 = editor.CreateNodeType(nt1, "nt2");
PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0);
editor.AddPropertyTypeToPropertySet(slot, nt1);
PropertyType pt2 = nt2.PropertyTypes["slot"];
editor.RemovePropertyTypeFromPropertySet(pt2, nt2);
Assert.IsNotNull(nt1.PropertyTypes["slot"], "#1");
Assert.IsNotNull(nt2.PropertyTypes["slot"], "#2");
Assert.IsNotNull(nt1.DeclaredPropertyTypes["slot"], "#3");
Assert.IsNull(nt2.DeclaredPropertyTypes["slot"], "#4");
}
public void SchemaEditor_RemovePropertyType_FromDeclarerType()
{
//-- krealunk egy torolhetot es felulirjuk
SchemaEditor editor = new SchemaEditor();
NodeType nt1 = editor.CreateNodeType(null, "nt1");
NodeType nt2 = editor.CreateNodeType(nt1, "nt2");
PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0);
editor.AddPropertyTypeToPropertySet(slot, nt1);
//-- meg kell jelenjen mindketton
PropertyType pt1 = nt1.PropertyTypes["slot"];
PropertyType pt2 = nt2.PropertyTypes["slot"];
//-- toroljuk a deklaralas eredeti helyerol
PropertyType pt = editor.PropertyTypes["slot"];
editor.RemovePropertyTypeFromPropertySet(pt, nt1);
//-- el kell tunjon mindkettorol
pt1 = nt1.PropertyTypes["slot"];
pt2 = nt2.PropertyTypes["slot"];
Assert.IsNull(nt1.PropertyTypes["slot"], "Ancestor PropertyType was not deleted");
Assert.IsNull(nt2.PropertyTypes["slot"], "Inherited PropertyType was not deleted");
}
internal static void ApplyChangesInEditor(ContentType contentType, SchemaEditor editor)
{
//-- Find ContentHandler
Type handlerType = TypeHandler.GetType(contentType.HandlerName);
if (handlerType == null)
throw new RegistrationException(String.Concat(
SR.Exceptions.Registration.Msg_ContentHandlerNotFound, ": ", contentType.HandlerName));
//-- parent type
NodeType parentNodeType = null;
if (contentType.ParentTypeName != null)
{
parentNodeType = editor.NodeTypes[contentType.ParentTypeName];
if (parentNodeType == null)
throw new ContentRegistrationException(SR.Exceptions.Registration.Msg_UnknownParentContentType, contentType.Name);
}
//-- handler type
NodeType nodeType = editor.NodeTypes[contentType.Name];
if (nodeType == null)
nodeType = editor.CreateNodeType(parentNodeType, contentType.Name, contentType.HandlerName);
if (nodeType.ClassName != contentType.HandlerName)
editor.ModifyNodeType(nodeType, contentType.HandlerName);
if (nodeType.Parent != parentNodeType)
editor.ModifyNodeType(nodeType, parentNodeType);
//-- 1: ContentHandler properties
NodeTypeRegistration ntReg = ParseAttributes(handlerType);
if (ntReg == null)
throw new ContentRegistrationException(
SR.Exceptions.Registration.Msg_DefinedHandlerIsNotAContentHandler, contentType.Name);
//-- 2: Field properties
foreach (FieldSetting fieldSetting in contentType.FieldSettings)
{
Type[][] slots = fieldSetting.HandlerSlots;
int fieldSlotCount = slots.GetLength(0);
if (fieldSetting.Bindings.Count != fieldSlotCount)
throw new ContentRegistrationException(String.Format(CultureInfo.InvariantCulture,
SR.Exceptions.Registration.Msg_FieldBindingsCount_1, fieldSlotCount), contentType.Name, fieldSetting.Name);
for (int i = 0; i < fieldSetting.Bindings.Count; i++)
{
string propName = fieldSetting.Bindings[i];
var dataType = fieldSetting.DataTypes[i];
CheckDataType(propName, dataType, contentType.Name, editor);
PropertyInfo propInfo = handlerType.GetProperty(propName);
if (propInfo != null)
{
//-- #1: there is a property under the slot:
bool ok = false;
for (int j = 0; j < slots[i].Length; j++)
{
//if (slots[i][j] == propInfo.PropertyType)
if (slots[i][j].IsAssignableFrom(propInfo.PropertyType))
{
PropertyTypeRegistration propReg = ntReg.PropertyTypeRegistrationByName(propName);
if (propInfo.DeclaringType != handlerType)
{
if (propReg == null)
{
object[] attrs = propInfo.GetCustomAttributes(typeof(RepositoryPropertyAttribute), false);
if (attrs.Length > 0)
{
propReg = new PropertyTypeRegistration(propInfo, (RepositoryPropertyAttribute)attrs[0]);
ntReg.PropertyTypeRegistrations.Add(propReg);
}
}
}
if (propReg != null && propReg.DataType != fieldSetting.DataTypes[i])
throw new ContentRegistrationException(String.Concat(
"The data type of the field in the content type definition does not match the data type of its content handler's property. ",
"Please modify the field type in the content type definition. ",
"ContentTypeDefinition: '", contentType.Name,
"', FieldName: '", fieldSetting.Name,
"', DataType of Field's binding: '", fieldSetting.DataTypes[i],
"', ContentHandler: '", handlerType.FullName,
"', PropertyName: '", propReg.Name,
"', DataType of property: '", propReg.DataType,
"'"));
ok = true;
fieldSetting.HandlerSlotIndices[i] = j;
fieldSetting.PropertyIsReadOnly = !PropertyHasPublicSetter(propInfo);
break;
}
}
if (!ok)
{
//if (fieldSetting.ShortName != "Reference")
// if (fieldSetting.DataTypes[i] != RepositoryDataType.Reference)
// throw new ContentRegistrationException(SR.Exceptions.Registration.Msg_PropertyAndFieldAreNotConnectable,
// contentType.Name, fieldSetting.Name);
//CheckReference(propInfo, slots[i], contentType, fieldSetting);
if (fieldSetting.ShortName == "Reference" || fieldSetting.DataTypes[i] == RepositoryDataType.Reference)
CheckReference(propInfo, slots[i], contentType, fieldSetting);
//else if (fieldSetting.ShortName == "Choice")
// CheckChoice(propInfo, slots[i], contentType, fieldSetting);
else
throw new ContentRegistrationException(SR.Exceptions.Registration.Msg_PropertyAndFieldAreNotConnectable,
contentType.Name, fieldSetting.Name);
}
}
else
{
//-- #2: there is not a property under the slot:
PropertyTypeRegistration propReg = new PropertyTypeRegistration(propName, dataType);
ntReg.PropertyTypeRegistrations.Add(propReg);
}
}
}
//-- Collect deletables. Check equals
foreach (PropertyType propType in nodeType.PropertyTypes.ToArray())
{
PropertyTypeRegistration propReg = ntReg.PropertyTypeRegistrationByName(propType.Name);
if (propReg == null)
{
editor.RemovePropertyTypeFromPropertySet(propType, nodeType);
}
}
//-- Register
foreach (PropertyTypeRegistration ptReg in ntReg.PropertyTypeRegistrations)
{
PropertyType propType = nodeType.PropertyTypes[ptReg.Name];
if (propType == null)
{
propType = editor.PropertyTypes[ptReg.Name];
if (propType == null)
propType = editor.CreatePropertyType(ptReg.Name, ConvertDataType(ptReg.DataType));
editor.AddPropertyTypeToPropertySet(propType, nodeType);
}
}
}
public void SchEd_WriterCalling_DeletePropertyType()
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
ed1.CreatePropertyType("PT1", DataType.String);
SetSchemaItemId(ed1.PropertyTypes["PT1"], 1);
//-- create current
ed2.CreatePropertyType("PT1", DataType.String);
SetSchemaItemId(ed2.PropertyTypes["PT1"], 1);
//-- edit
ed2.DeletePropertyType(ed2.PropertyTypes["PT1"]);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string log = wr.Log.Replace("\r\n", "");
Assert.IsTrue(log == "Open();DeletePropertyType(propertyType=<PT1>);Close();");
}
