public void SchemaWriter_AddPropertyTypeToContentListType()
{
IntegrationTest(() =>
{
var ed = new SchemaEditor();
ed.Load();
var lt = ed.CreateContentListType("LT0" + Guid.NewGuid());
// ACTION
var pt0 = ed.CreateContentListPropertyType(DataType.String, GetNextMapping(ed, true));
var pt1 = ed.CreateContentListPropertyType(DataType.Int, GetNextMapping(ed, true));
var pt2 = ed.CreateContentListPropertyType(DataType.String, GetNextMapping(ed, true));
var pt3 = ed.CreateContentListPropertyType(DataType.Int, GetNextMapping(ed, true));
ed.AddPropertyTypeToPropertySet(pt0, lt);
ed.AddPropertyTypeToPropertySet(pt1, lt);
ed.AddPropertyTypeToPropertySet(pt2, lt);
ed.AddPropertyTypeToPropertySet(pt3, lt);
ed.Register();
// ASSERT
var schema = DP.LoadSchemaAsync(CancellationToken.None).GetAwaiter().GetResult();
var ltData = schema.ContentListTypes.First(x => x.Name == lt.Name);
AssertSequenceEqual(new[] { pt0.Name, pt1.Name, pt2.Name, pt3.Name }, ltData.Properties);
});
}
public void SchEd_WriterCalling_ModifyNodeType_ChangeParent()
{
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.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", "T1"); SetSchemaItemId(ed1.NodeTypes["NT1"], 1);
NodeType nt2 = ed1.CreateNodeType(null, "NT2", "T2"); SetSchemaItemId(ed1.NodeTypes["NT2"], 2);
NodeType nt3 = ed1.CreateNodeType(nt1, "NT3", "T3"); 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", "T1"); SetSchemaItemId(ed2.NodeTypes["NT1"], 1);
nt2 = ed2.CreateNodeType(null, "NT2", "T2"); SetSchemaItemId(ed2.NodeTypes["NT2"], 2);
nt3 = ed2.CreateNodeType(nt1, "NT3", "T3"); 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=<T3>);
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 SchEd_WriterCalling_RemoveOverriddenPropertyFromNodeType()
{
Test(() =>
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
PropertyType pt1 = CreatePropertyType(ed1, "PT1", DataType.String, 1);
NodeType nt1 = CreateNodeType(ed1, null, "NT1", "NT1", 1);
NodeType nt2 = CreateNodeType(ed1, nt1, "NT2", "NT2", 2);
NodeType nt3 = CreateNodeType(ed1, nt2, "NT3", "NT3", 3);
NodeType nt4 = CreateNodeType(ed1, nt3, "NT4", "NT4", 4);
NodeType nt5 = CreateNodeType(ed1, nt4, "NT5", "NT5", 5);
ed1.AddPropertyTypeToPropertySet(pt1, nt4);
ed1.AddPropertyTypeToPropertySet(pt1, nt2);
//-- create current
XmlDocument xd = new XmlDocument();
xd.LoadXml(ed1.ToXml());
ed2.Load(xd);
//-- edit
ed2.RemovePropertyTypeFromPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT4"]);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string log = wr.Log.Replace("\r\n", "");
Assert.IsTrue(log == "Open();UpdatePropertyTypeDeclarationState(propType=<PT1>, newSet=<NT4>, isDeclared=<False>);Close();");
});
}
public void SchemaEditor_RemoveAncestorOfOverriddenPropertyFromNodeType()
{
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");
NodeType nt4 = editor.CreateNodeType(nt3, "NT4", "T4");
NodeType nt5 = editor.CreateNodeType(nt4, "NT5", "T5");
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_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_RemovePropertyType_FromTopReDeclarerType()
{
SchemaEditor editor = new SchemaEditor();
NodeType nt1 = editor.CreateNodeType(null, "nt1", "t1");
NodeType nt2 = editor.CreateNodeType(nt1, "nt2", "t2");
NodeType nt3 = editor.CreateNodeType(nt2, "nt3", "t3");
PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0);
editor.AddPropertyTypeToPropertySet(slot, nt2);
editor.AddPropertyTypeToPropertySet(slot, nt1);
//-- propertyType need to appear in all three nodeTypes
PropertyType pt1 = nt1.PropertyTypes["slot"];
PropertyType pt2 = nt2.PropertyTypes["slot"];
PropertyType pt3 = nt3.PropertyTypes["slot"];
//-- delete from the original place
PropertyType pt = editor.PropertyTypes["slot"];
editor.RemovePropertyTypeFromPropertySet(pt, nt1);
//-- propertyType need to disappear from all three nodeTypes
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 SqlSchemaWriter_RemovePropertyTypeFromNodeType_Text()
{
SchemaEditor ed = new SchemaEditor();
NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1);
PropertyType pt = CreatePropertyType(ed, "PT0", DataType.Text, 2);
ed.AddPropertyTypeToPropertySet(pt, nt);
var writer = SqlSchemaWriterAccessor.Create();
writer.Open();
writer.RemovePropertyTypeFromPropertySet(pt, nt);
string expectedSql = @"-- Reset property value: NT0.PT0:Text
DELETE FROM dbo.TextPropertiesNVarchar WHERE TextPropertyNVarcharId IN (SELECT dbo.TextPropertiesNVarchar.TextPropertyNVarcharId FROM dbo.Nodes
INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId
INNER JOIN dbo.TextPropertiesNVarchar ON dbo.Versions.VersionId = dbo.TextPropertiesNVarchar.VersionId
WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.TextPropertiesNVarchar.PropertyTypeId = 2))
-- Reset property value: NT0.PT0:Text
DELETE FROM dbo.TextPropertiesNText WHERE TextPropertyNTextId IN (SELECT dbo.TextPropertiesNText.TextPropertyNTextId FROM dbo.Nodes
INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId
INNER JOIN dbo.TextPropertiesNText ON dbo.Versions.VersionId = dbo.TextPropertiesNText.VersionId
WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.TextPropertiesNText.PropertyTypeId = 2))
-- Remove PropertyType 'PT0' from PropertySet 'NT0'
DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1
GO
";
string sql = writer.GetSqlScript();
Assert.IsTrue(ScriptsAreEqual(sql, expectedSql));
}
public void SqlSchemaWriter_RemovePropertyTypeFromNodeType_String()
{
SchemaEditor ed = new SchemaEditor();
NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1);
PropertyType pt = CreatePropertyType(ed, "PT0", DataType.String, 2);
ed.AddPropertyTypeToPropertySet(pt, nt);
var writer = SqlSchemaWriterAccessor.Create();
writer.Open();
writer.RemovePropertyTypeFromPropertySet(pt, nt);
string expectedSql = @"
-- Reset property values
UPDATE dbo.FlatProperties
SET nvarchar_1 = NULL
WHERE Id IN (SELECT dbo.FlatProperties.Id FROM dbo.Nodes
INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId
INNER JOIN dbo.FlatProperties ON dbo.Versions.VersionId = dbo.FlatProperties.VersionId
WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.FlatProperties.Page = 0))
-- Remove PropertyType 'PT0' from PropertySet 'NT0'
DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1
GO" ;
string sql = writer.GetSqlScript();
Assert.IsTrue(ScriptsAreEqual(sql, expectedSql));
}
public void SqlSchemaWriter_RemovePropertyTypeFromNodeType_Reference()
{
SchemaEditor ed = new SchemaEditor();
NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1);
PropertyType pt = CreatePropertyType(ed, "PT0", DataType.Reference, 2);
ed.AddPropertyTypeToPropertySet(pt, nt);
var writer = SqlSchemaWriterAccessor.Create();
writer.Open();
writer.RemovePropertyTypeFromPropertySet(pt, nt);
string expectedSql = @"
-- Reset property value: NT0.PT0:Reference
DELETE FROM dbo.ReferenceProperties WHERE ReferencePropertyId IN (SELECT dbo.ReferenceProperties.ReferencePropertyId FROM dbo.Nodes
INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId
INNER JOIN dbo.ReferenceProperties ON dbo.Versions.VersionId = dbo.ReferenceProperties.VersionId
WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.ReferenceProperties.PropertyTypeId = 2))
-- Remove PropertyType 'PT0' from PropertySet 'NT0'
DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1
GO" ;
string sql = writer.GetSqlScript();
AssertScriptsAreEqual(expectedSql, sql);;
}
public void SchEd_WriterCalling_CreateNodeType()
{
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);
//-- create current
ed2.CreatePropertyType("PT1", DataType.String);
SetSchemaItemId(ed2.PropertyTypes["PT1"], 1);
//-- edit
ed2.CreateNodeType(null, "NT1", "T1");
ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string expectedLog = @"
Open();
CreateNodeType(parent=<[null]>, name=<NT1>, className=<T1>);
AddPropertyTypeToPropertySet(propertyType=<PT1>, owner=<NT1>, isDeclared=<True>);
Close();
" .Replace("\r\n", "").Replace("\t", "");
string log = wr.Log.Replace("\r\n", "");
Assert.IsTrue(log == expectedLog);
});
}
public void SchemaEditor_RemovePropertyType_FromDeclarerType()
{
//-- create a deletable and inherit from it
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 need to appear on both nodeType
PropertyType pt1 = nt1.PropertyTypes["slot"];
PropertyType pt2 = nt2.PropertyTypes["slot"];
//-- delete from the original place
PropertyType pt = editor.PropertyTypes["slot"];
editor.RemovePropertyTypeFromPropertySet(pt, nt1);
//-- propertyType need to disappear from both nodeType
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");
}
public void SchEd_WriterCalling_CreateContentListType()
{
Test(() =>
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
ed1.CreateContentListPropertyType(DataType.String, 0);
SetSchemaItemId(ed1.PropertyTypes["#String_0"], 1);
//-- create current
ed2.CreateContentListPropertyType(DataType.String, 0);
SetSchemaItemId(ed2.PropertyTypes["#String_0"], 1);
//-- edit
ed2.CreateContentListType("LT1");
ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["#String_0"], ed2.ContentListTypes["LT1"]);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string expectedLog = @"
Open();
CreateContentListType(name=<LT1>);
AddPropertyTypeToPropertySet(propertyType=<#String_0>, owner=<LT1>, isDeclared=<True>);
Close();
" .Replace("\r\n", "").Replace("\t", "");
string log = wr.Log.Replace("\r\n", "");
Assert.IsTrue(log == expectedLog);
});
}
public void SchEd_WriterCalling_ModifyNodeType()
{
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.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_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");
}
private FieldSetting CreateNewFieldType(FieldDescriptor fieldInfo, Dictionary <string, List <string> > newBindings, ContentListType listType, SlotTable slotTable, SchemaEditor editor)
{
List <string> bindList = new List <string>();
foreach (RepositoryDataType slotType in FieldManager.GetDataTypes(fieldInfo.FieldTypeShortName))
{
if (slotType == RepositoryDataType.NotDefined)
{
continue;
}
int slotNumber = slotTable.ReserveSlot((DataType)slotType);
string binding = EncodeBinding(slotType, slotNumber);
bindList.Add(binding);
PropertyType pt = editor.PropertyTypes[binding];
if (pt == null)
{
pt = editor.CreateContentListPropertyType((DataType)slotType, slotNumber);
}
editor.AddPropertyTypeToPropertySet(pt, listType);
}
newBindings.Add(fieldInfo.FieldName, bindList);
return(FieldSetting.Create(fieldInfo, bindList, null));
}
//================================================= 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 SchemaEditor_AddWrongPropertyToNodeType()
{
SchemaEditor editor = new SchemaEditor();
PropertyType pt1 = editor.CreateContentListPropertyType(DataType.String, 0);
NodeType nt1 = editor.CreateNodeType(null, "NT1", "T1");
editor.AddPropertyTypeToPropertySet(pt1, nt1);
}
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 SchemaEditor_RemovePropertyType_NullPropertyType()
{
//---- Target item cannot be null
SchemaEditor editor = new SchemaEditor();
NodeType nt = editor.CreateNodeType(null, "nt", "t");
PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0);
editor.AddPropertyTypeToPropertySet(slot, nt);
new SchemaEditor().RemovePropertyTypeFromPropertySet(slot, null);
}
public void SchemaEditor_AddPropertyToContentListType()
{
SchemaEditor editor = new SchemaEditor();
PropertyType pt1 = editor.CreateContentListPropertyType(DataType.String, 0);
var lt1 = editor.CreateContentListType("LT1");
editor.AddPropertyTypeToPropertySet(pt1, lt1);
Assert.IsNotNull(lt1.PropertyTypes["#String_0"], "#1");
Assert.IsTrue(lt1.Id == 0, "#2");
}
public void SchemaEditor_RemoveNodeType()
{
SchemaEditor editor = new SchemaEditor();
NodeType nt1 = editor.CreateNodeType(null, "NT1", "T1");
NodeType nt2 = editor.CreateNodeType(nt1, "NT2", "T2");
NodeType nt3 = editor.CreateNodeType(nt2, "NT3", "T3");
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 SchEd_WriterCalling_Complex_01()
{
Test(() =>
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
PropertyType ptX = CreatePropertyType(ed1, "X", DataType.String, 1);
PropertyType ptY = CreatePropertyType(ed1, "Y", DataType.String, 2);
PropertyType ptZ = CreatePropertyType(ed1, "Z", DataType.String, 3);
NodeType ntA = CreateNodeType(ed1, null, "A", null, 1);
NodeType ntB = CreateNodeType(ed1, ntA, "B", null, 2);
NodeType ntC = CreateNodeType(ed1, ntB, "C", null, 3);
ed1.AddPropertyTypeToPropertySet(ptX, ntB);
ed1.AddPropertyTypeToPropertySet(ptY, ntC);
ed1.AddPropertyTypeToPropertySet(ptX, ntA);
//-- create current
XmlDocument xd = new XmlDocument();
xd.LoadXml(ed1.ToXml());
ed2.Load(xd);
ptX = ed2.PropertyTypes["X"];
ptY = ed2.PropertyTypes["Y"];
ptZ = ed2.PropertyTypes["Z"];
ntA = ed2.NodeTypes["A"];
ntB = ed2.NodeTypes["B"];
ntC = ed2.NodeTypes["C"];
//-- edit
ed2.RemovePropertyTypeFromPropertySet(ptX, ntA);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string log = wr.Log.Replace("\r\n", "");
Assert.IsTrue(log == "Open();RemovePropertyTypeFromPropertySet(propertyType=<X>, owner=<A>);Close();");
});
}
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_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_CreateNodeType()
{
SchemaEditor editor = new SchemaEditor();
PropertyType slot = editor.CreatePropertyType("slot", DataType.String);
NodeType nt1 = editor.CreateNodeType(null, "NT1", "T1");
editor.AddPropertyTypeToPropertySet(slot, nt1);
NodeType nt2 = editor.CreateNodeType(nt1, "NT2", "T2");
Assert.IsNotNull(nt2.PropertyTypes["slot"]);
Assert.IsTrue(nt1.Id == 0, "Id was not 0");
}
public void SchEd_WriterCalling_RemoveAncestorOfOverriddenPropertyFromNodeType()
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
PropertyType pt1 = CreatePropertyType(ed1, "PT1", DataType.String, 1);
NodeType nt1 = CreateNodeType(ed1, null, "NT1", "NT1", 1);
NodeType nt2 = CreateNodeType(ed1, nt1, "NT2", "NT2", 2);
NodeType nt3 = CreateNodeType(ed1, nt2, "NT3", "NT3", 3);
NodeType nt4 = CreateNodeType(ed1, nt3, "NT4", "NT4", 4);
NodeType nt5 = CreateNodeType(ed1, nt4, "NT5", "NT5", 5);
ed1.AddPropertyTypeToPropertySet(pt1, nt4);
ed1.AddPropertyTypeToPropertySet(pt1, nt2);
//-- create current
XmlDocument xd = new XmlDocument();
xd.LoadXml(ed1.ToXml());
ed2.Load(xd);
//-- edit
ed2.RemovePropertyTypeFromPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT2"]);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string expectedLog = @"
Open();
RemovePropertyTypeFromPropertySet(propertyType=<PT1>, owner=<NT2>);
RemovePropertyTypeFromPropertySet(propertyType=<PT1>, owner=<NT3>);
Close();" .Replace("\r\n", "").Replace("\t", "").Replace(" ", "");
string log = wr.Log.Replace("\r\n", "").Replace(" ", "");
Assert.IsTrue(log == expectedLog);
}
public void SchemaEditor_RemoveContentListType()
{
SchemaEditor editor = new SchemaEditor();
var lt1 = editor.CreateContentListType("LT1");
PropertyType slot1 = editor.CreateContentListPropertyType(DataType.String, 0);
editor.AddPropertyTypeToPropertySet(slot1, lt1);
editor.DeleteContentListType(editor.ContentListTypes["LT1"]);
Assert.IsTrue(editor.ContentListTypes.Count == 0);
}
public void SchemaEditor_CreatePropertyType_WrongPropertySlotContext()
{
//-- wrong context (PropertySlot)
SchemaEditor editor1 = new SchemaEditor();
SchemaEditor editor2 = new SchemaEditor();
editor1.CreatePropertyType("slot", DataType.String);
editor1.CreateNodeType(null, "nt", "t");
editor2.CreatePropertyType("slot", DataType.String);
editor2.CreateNodeType(null, "nt", "t");
NodeType owner = editor1.NodeTypes["nt"];
PropertyType slot = editor2.PropertyTypes["slot"];
editor1.AddPropertyTypeToPropertySet(slot, owner);
}
public void SchemaEditor_RemovePropertyType_WrongContext()
{
//-- wrong context
SchemaEditor editor = new SchemaEditor();
NodeType nt = editor.CreateNodeType(null, "nt", "t");
PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0);
editor.AddPropertyTypeToPropertySet(slot, nt);
SchemaEditor editor1 = new SchemaEditor();
nt = editor1.CreateNodeType(null, "nt", "t");
slot = editor1.CreatePropertyType("slot", DataType.String, 0);
editor1.AddPropertyTypeToPropertySet(slot, nt);
editor.RemovePropertyTypeFromPropertySet(editor1.PropertyTypes["slot"], editor1.NodeTypes["nt"]);
}
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_RemoveContentListType()
{
SchemaEditor editor = new SchemaEditor();
var lt1 = editor.CreateContentListType("LT1");
PropertyType slot1 = editor.CreateContentListPropertyType(DataType.String, 0);
editor.AddPropertyTypeToPropertySet(slot1, lt1);
editor.DeleteContentListType(editor.ContentListTypes["LT1"]);
Assert.IsTrue(editor.ContentListTypes.Count == 0);
}
public void SchEd_WriterCalling_DeleteContentListType()
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
ed1.CreateContentListPropertyType(DataType.String, 0);
SetSchemaItemId(ed1.PropertyTypes["#String_0"], 1);
ed1.CreateContentListType("LT1");
SetSchemaItemId(ed1.ContentListTypes["LT1"], 1);
ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["#String_0"], ed1.ContentListTypes["LT1"]);
//-- create current
ed2.CreateContentListPropertyType(DataType.String, 0);
SetSchemaItemId(ed2.PropertyTypes["#String_0"], 1);
ed2.CreateContentListType("LT1");
SetSchemaItemId(ed2.ContentListTypes["LT1"], 1);
ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["#String_0"], ed2.ContentListTypes["LT1"]);
//-- edit
ed2.DeleteContentListType(ed2.ContentListTypes["LT1"]);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string expectedLog = @"
Open();
DeleteContentListType(contentListType=<LT1>);
Close();
".Replace("\r\n", "").Replace("\t", "").Replace(" ", "");
string log = wr.Log.Replace("\r\n", "").Replace(" ", "");
Assert.IsTrue(log == expectedLog);
}
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_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 SchEd_WriterCalling_Complex_01()
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
PropertyType ptX = CreatePropertyType(ed1, "X", DataType.String, 1);
PropertyType ptY = CreatePropertyType(ed1, "Y", DataType.String, 2);
PropertyType ptZ = CreatePropertyType(ed1, "Z", DataType.String, 3);
NodeType ntA = CreateNodeType(ed1, null, "A", null, 1);
NodeType ntB = CreateNodeType(ed1, ntA, "B", null, 2);
NodeType ntC = CreateNodeType(ed1, ntB, "C", null, 3);
ed1.AddPropertyTypeToPropertySet(ptX, ntB);
ed1.AddPropertyTypeToPropertySet(ptY, ntC);
ed1.AddPropertyTypeToPropertySet(ptX, ntA);
//-- create current
XmlDocument xd = new XmlDocument();
xd.LoadXml(ed1.ToXml());
ed2.Load(xd);
ptX = ed2.PropertyTypes["X"];
ptY = ed2.PropertyTypes["Y"];
ptZ = ed2.PropertyTypes["Z"];
ntA = ed2.NodeTypes["A"];
ntB = ed2.NodeTypes["B"];
ntC = ed2.NodeTypes["C"];
//-- edit
ed2.RemovePropertyTypeFromPropertySet(ptX, ntA);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string log = wr.Log.Replace("\r\n", "");
Assert.IsTrue(log == "Open();RemovePropertyTypeFromPropertySet(propertyType=<X>, owner=<A>);Close();");
}
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_AddWrongPropertyToContentListType()
{
SchemaEditor editor = new SchemaEditor();
PropertyType pt1 = editor.CreatePropertyType("PT1", DataType.String);
var lt1 = editor.CreateContentListType("LT1");
editor.AddPropertyTypeToPropertySet(pt1, lt1);
}
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_RemoveAncestorOfOverriddenPropertyFromNodeType()
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
PropertyType pt1 = CreatePropertyType(ed1, "PT1", DataType.String, 1);
NodeType nt1 = CreateNodeType(ed1, null, "NT1", "NT1", 1);
NodeType nt2 = CreateNodeType(ed1, nt1, "NT2", "NT2", 2);
NodeType nt3 = CreateNodeType(ed1, nt2, "NT3", "NT3", 3);
NodeType nt4 = CreateNodeType(ed1, nt3, "NT4", "NT4", 4);
NodeType nt5 = CreateNodeType(ed1, nt4, "NT5", "NT5", 5);
ed1.AddPropertyTypeToPropertySet(pt1, nt4);
ed1.AddPropertyTypeToPropertySet(pt1, nt2);
//-- create current
XmlDocument xd = new XmlDocument();
xd.LoadXml(ed1.ToXml());
ed2.Load(xd);
//-- edit
ed2.RemovePropertyTypeFromPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT2"]);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string expectedLog = @"
Open();
RemovePropertyTypeFromPropertySet(propertyType=<PT1>, owner=<NT2>);
RemovePropertyTypeFromPropertySet(propertyType=<PT1>, owner=<NT3>);
Close();".Replace("\r\n", "").Replace("\t", "").Replace(" ", "");
string log = wr.Log.Replace("\r\n", "").Replace(" ", "");
Assert.IsTrue(log == expectedLog);
}
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");
}
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 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");
}
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_AddPropertyToContentListType()
{
SchemaEditor editor = new SchemaEditor();
PropertyType pt1 = editor.CreateContentListPropertyType(DataType.String, 0);
var lt1 = editor.CreateContentListType("LT1");
editor.AddPropertyTypeToPropertySet(pt1, lt1);
Assert.IsNotNull(lt1.PropertyTypes["#String_0"], "#1");
Assert.IsTrue(lt1.Id == 0, "#2");
}
public void SqlSchemaWriter_RemovePropertyTypeFromNodeType_More()
{
//CreateTestNodeForRemovePropertyType();
SchemaEditor ed = new SchemaEditor();
NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1);
PropertyType pt0 = CreatePropertyType(ed, "PT0", DataType.String, 2);
PropertyType pt1 = CreatePropertyType(ed, "PT1", DataType.String, 3);
PropertyType pt2 = CreatePropertyType(ed, "PT2", DataType.String, 4);
ed.AddPropertyTypeToPropertySet(pt0, nt);
ed.AddPropertyTypeToPropertySet(pt1, nt);
ed.AddPropertyTypeToPropertySet(pt2, nt);
var writer = SqlSchemaWriterAccessor.Create();
writer.Open();
writer.RemovePropertyTypeFromPropertySet(pt0, nt);
writer.RemovePropertyTypeFromPropertySet(pt1, nt);
writer.RemovePropertyTypeFromPropertySet(pt2, nt);
#region Bad script
//-- Reset property value: NT0.PT0:String
//UPDATE dbo.FlatProperties SET nvarchar_1 = NULL
//WHERE Id IN (SELECT dbo.FlatProperties.Id FROM dbo.Nodes
// INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId
// INNER JOIN dbo.FlatProperties ON dbo.Versions.VersionId = dbo.FlatProperties.VersionId
// WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.FlatProperties.Page = 0))
//-- Remove PropertyType 'PT0' from PropertySet 'NT0'
//DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1
//GO
//-- Reset property value: NT0.PT1:String
//UPDATE dbo.FlatProperties SET nvarchar_2 = NULL
//WHERE Id IN (SELECT dbo.FlatProperties.Id FROM dbo.Nodes
// INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId
// INNER JOIN dbo.FlatProperties ON dbo.Versions.VersionId = dbo.FlatProperties.VersionId
// WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.FlatProperties.Page = 0))
//-- Remove PropertyType 'PT1' from PropertySet 'NT0'
//DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 3 AND PropertySetId = 1
//GO
//-- Reset property value: NT0.PT2:String
//UPDATE dbo.FlatProperties SET nvarchar_3 = NULL
//WHERE Id IN (SELECT dbo.FlatProperties.Id FROM dbo.Nodes
// INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId
// INNER JOIN dbo.FlatProperties ON dbo.Versions.VersionId = dbo.FlatProperties.VersionId
// WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.FlatProperties.Page = 0))
//-- Remove PropertyType 'PT2' from PropertySet 'NT0'
//DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 4 AND PropertySetId = 1
//GO
#endregion
string expectedSql = @"
-- Reset property values
UPDATE dbo.FlatProperties
SET nvarchar_1 = NULL,
nvarchar_2 = NULL,
nvarchar_3 = NULL
WHERE Id IN (SELECT dbo.FlatProperties.Id FROM dbo.Nodes
INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId
INNER JOIN dbo.FlatProperties ON dbo.Versions.VersionId = dbo.FlatProperties.VersionId
WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.FlatProperties.Page = 0))
-- Remove PropertyType 'PT0' from PropertySet 'NT0'
DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1
GO
-- Remove PropertyType 'PT1' from PropertySet 'NT0'
DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 3 AND PropertySetId = 1
GO
-- Remove PropertyType 'PT2' from PropertySet 'NT0'
DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 4 AND PropertySetId = 1
GO";
string sql = writer.GetSqlScript();
Assert.IsTrue(ScriptsAreEqual(sql, expectedSql));
}
public void SchEd_WriterCalling_OverridePropertyOnNodeType()
{
SchemaEditor ed1 = new SchemaEditor();
SchemaEditor ed2 = new SchemaEditor();
SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2);
TestSchemaWriter wr = new TestSchemaWriter();
//-- create original
PropertyType pt1 = CreatePropertyType(ed1, "PT1", DataType.String, 1);
NodeType nt1 = CreateNodeType(ed1, null, "NT1", "NT1", 1);
NodeType nt2 = CreateNodeType(ed1, nt1, "NT2", "NT2", 2);
NodeType nt3 = CreateNodeType(ed1, nt2, "NT3", "NT3", 3);
NodeType nt4 = CreateNodeType(ed1, nt3, "NT4", "NT4", 4);
NodeType nt5 = CreateNodeType(ed1, nt4, "NT5", "NT5", 5);
ed1.AddPropertyTypeToPropertySet(pt1, nt2);
//-- create current
XmlDocument xd = new XmlDocument();
xd.LoadXml(ed1.ToXml());
ed2.Load(xd);
//-- edit
ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT4"]);
//-- register
ed2Acc.RegisterSchema(ed1, wr);
//-- test
string log = wr.Log.Replace("\r\n", "");
Assert.IsTrue(log == "Open();UpdatePropertyTypeDeclarationState(propType=<PT1>, newSet=<NT4>, isDeclared=<True>);Close();");
}
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");
}
//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_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);
}
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_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 SchemaEditor_AddWrongPropertyToNodeType()
{
SchemaEditor editor = new SchemaEditor();
PropertyType pt1 = editor.CreateContentListPropertyType(DataType.String, 0);
NodeType nt1 = editor.CreateNodeType(null, "NT1");
editor.AddPropertyTypeToPropertySet(pt1, nt1);
}
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_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 SqlSchemaWriter_UpdatePropertyTypeDeclarationState()
{
SchemaEditor ed = new SchemaEditor();
NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1);
PropertyType pt = CreatePropertyType(ed, "PT0", DataType.String, 2);
ed.AddPropertyTypeToPropertySet(pt, nt);
var writer = SqlSchemaWriterAccessor.Create();
writer.Open();
writer.UpdatePropertyTypeDeclarationState(pt, nt, true);
string expectedSql = @"
-- Update PropertyType declaration: NT0.PT0. Set IsDeclared = true
UPDATE [dbo].[SchemaPropertySetsPropertyTypes] SET
[IsDeclared] = 1
WHERE PropertySetId = 1 AND PropertyTypeId = 2
GO";
string sql = writer.GetSqlScript();
Assert.IsTrue(ScriptsAreEqual(sql, expectedSql));
}
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);
}
private FieldSetting CreateNewFieldType(FieldDescriptor fieldInfo, Dictionary<string, List<string>> newBindings, ContentListType listType, SlotTable slotTable, SchemaEditor editor)
{
List<string> bindList = new List<string>();
foreach (RepositoryDataType slotType in FieldManager.GetDataTypes(fieldInfo.FieldTypeShortName))
{
if (slotType == RepositoryDataType.NotDefined)
continue;
int slotNumber = slotTable.ReserveSlot((DataType)slotType);
string binding = EncodeBinding(slotType, slotNumber);
bindList.Add(binding);
PropertyType pt = editor.PropertyTypes[binding];
if (pt == null)
pt = editor.CreateContentListPropertyType((DataType)slotType, slotNumber);
editor.AddPropertyTypeToPropertySet(pt, listType);
}
newBindings.Add(fieldInfo.FieldName, bindList);
return FieldSetting.Create(fieldInfo, bindList);
}
public void SqlSchemaWriter_RemovePropertyTypeFromNodeType_String()
{
SchemaEditor ed = new SchemaEditor();
NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1);
PropertyType pt = CreatePropertyType(ed, "PT0", DataType.String, 2);
ed.AddPropertyTypeToPropertySet(pt, nt);
var writer = SqlSchemaWriterAccessor.Create();
writer.Open();
writer.RemovePropertyTypeFromPropertySet(pt, nt);
string expectedSql = @"
-- Reset property values
UPDATE dbo.FlatProperties
SET nvarchar_1 = NULL
WHERE Id IN (SELECT dbo.FlatProperties.Id FROM dbo.Nodes
INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId
INNER JOIN dbo.FlatProperties ON dbo.Versions.VersionId = dbo.FlatProperties.VersionId
WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.FlatProperties.Page = 0))
-- Remove PropertyType 'PT0' from PropertySet 'NT0'
DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1
GO";
string sql = writer.GetSqlScript();
Assert.IsTrue(ScriptsAreEqual(sql, expectedSql));
}
public void SqlSchemaWriter_RemovePropertyTypeFromNodeType_Text()
{
SchemaEditor ed = new SchemaEditor();
NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1);
PropertyType pt = CreatePropertyType(ed, "PT0", DataType.Text, 2);
ed.AddPropertyTypeToPropertySet(pt, nt);
var writer = SqlSchemaWriterAccessor.Create();
writer.Open();
writer.RemovePropertyTypeFromPropertySet(pt, nt);
string expectedSql = @"-- Reset property value: NT0.PT0:Text
DELETE FROM dbo.TextPropertiesNVarchar WHERE TextPropertyNVarcharId IN (SELECT dbo.TextPropertiesNVarchar.TextPropertyNVarcharId FROM dbo.Nodes
INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId
INNER JOIN dbo.TextPropertiesNVarchar ON dbo.Versions.VersionId = dbo.TextPropertiesNVarchar.VersionId
WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.TextPropertiesNVarchar.PropertyTypeId = 2))
-- Reset property value: NT0.PT0:Text
DELETE FROM dbo.TextPropertiesNText WHERE TextPropertyNTextId IN (SELECT dbo.TextPropertiesNText.TextPropertyNTextId FROM dbo.Nodes
INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId
INNER JOIN dbo.TextPropertiesNText ON dbo.Versions.VersionId = dbo.TextPropertiesNText.VersionId
WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.TextPropertiesNText.PropertyTypeId = 2))
-- Remove PropertyType 'PT0' from PropertySet 'NT0'
DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1
GO
";
string sql = writer.GetSqlScript();
Assert.IsTrue(ScriptsAreEqual(sql, expectedSql));
}
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();");
}
