protected override void OnModelCreating(ModelBuilder modelBuilder)
{
RemoveVariableModelAnnotations(modelBuilder);
modelBuilder.Entity <Patriarch>().HasData(
new { Id = HierarchyId.GetRoot(), Name = "Eddard Stark" },
new { Id = HierarchyId.Parse("/1/"), Name = "Robb Stark" },
new { Id = HierarchyId.Parse("/2/"), Name = "Jon Snow" });
modelBuilder.Entity <ConvertedPatriarch>(b =>
{
b.Property(e => e.HierarchyId)
.HasConversion(v => HierarchyId.Parse(v), v => v.ToString());
b.HasData(
new ConvertedPatriarch {
Id = 1, HierarchyId = HierarchyId.GetRoot().ToString(), Name = "Eddard Stark"
},
new ConvertedPatriarch {
Id = 2, HierarchyId = HierarchyId.Parse("/1/").ToString(), Name = "Robb Stark"
},
new ConvertedPatriarch {
Id = 3, HierarchyId = HierarchyId.Parse("/2/").ToString(), Name = "Jon Snow"
});
});
}
//public void Add(ProductCategoryDto add, int? parentId)
//{
// var entity = Context.HierarchyCategory.Create();
// entity.Name = add.Name;
// Context.HierarchyCategory.Add(entity);
// Context.SaveChanges();
// if (!parentId.HasValue)
// {
// entity.Level = HierarchyId.Parse(string.Format("/{0}/", entity.Id));
// }
// else
// {
// var parentEntity = Context.HierarchyCategory.FirstOrDefault(x => x.Id == parentId);
// entity.Level = HierarchyId.Parse(string.Format("{0}{1}/", parentEntity.Level.ToString(), entity.Id));
// }
// Context.SaveChanges();
//}
public void Add(ProductCategoryDto add, int?parentId)
{
var entity = Context.HierarchyCategory.Create();
entity.Name = add.Name;
HierarchyId parentItem;
HierarchyCategory lastItemInCurrentLevel;
if (!parentId.HasValue)
{
parentItem = HierarchyId.GetRoot();
}
else
{
parentItem = Context.HierarchyCategory.FirstOrDefault(x => x.Id == parentId).Level;
}
lastItemInCurrentLevel = Context.HierarchyCategory
.Where(x => x.Level.GetAncestor(1) == parentItem)
.OrderByDescending(x => x.Level)
.FirstOrDefault();
var child1Level = lastItemInCurrentLevel != null ? lastItemInCurrentLevel.Level : null;
var newLevel = parentItem.GetDescendant(child1Level, null);
entity.Level = newLevel;
Context.HierarchyCategory.Add(entity);
Context.SaveChanges();
}
// <summary>
// Initializes a map from primitive scalar types in the C-Space to default values
// used within the placeholder.
// </summary>
private static Dictionary <PrimitiveTypeKind, object> InitializeTypeDefaultMap()
{
var typeDefaultMap = new Dictionary <PrimitiveTypeKind, object>(
EqualityComparer <PrimitiveTypeKind> .Default);
// Use CLR defaults for value types, arbitrary constants for reference types
// (since these default to null)
typeDefaultMap[PrimitiveTypeKind.Binary] = new Byte[0];
typeDefaultMap[PrimitiveTypeKind.Boolean] = default(Boolean);
typeDefaultMap[PrimitiveTypeKind.Byte] = default(Byte);
typeDefaultMap[PrimitiveTypeKind.DateTime] = default(DateTime);
typeDefaultMap[PrimitiveTypeKind.Time] = default(TimeSpan);
typeDefaultMap[PrimitiveTypeKind.DateTimeOffset] = default(DateTimeOffset);
typeDefaultMap[PrimitiveTypeKind.Decimal] = default(Decimal);
typeDefaultMap[PrimitiveTypeKind.Double] = default(Double);
typeDefaultMap[PrimitiveTypeKind.Guid] = default(Guid);
typeDefaultMap[PrimitiveTypeKind.Int16] = default(Int16);
typeDefaultMap[PrimitiveTypeKind.Int32] = default(Int32);
typeDefaultMap[PrimitiveTypeKind.Int64] = default(Int64);
typeDefaultMap[PrimitiveTypeKind.Single] = default(Single);
typeDefaultMap[PrimitiveTypeKind.SByte] = default(SByte);
typeDefaultMap[PrimitiveTypeKind.String] = String.Empty;
typeDefaultMap[PrimitiveTypeKind.HierarchyId] = HierarchyId.GetRoot();
#if DEBUG
foreach (var o in typeDefaultMap.Values)
{
Debug.Assert(null != o, "DbConstantExpression instances do not support null values");
}
#endif
return(typeDefaultMap);
}
public List <ProductCategoryDto> GetAll()
{
var root = HierarchyId.GetRoot();
var parentEntity = Context.HierarchyCategory.FirstOrDefault(x => x.Level.IsDescendantOf(root));
return(new List <ProductCategoryDto>());
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
RemoveVariableModelAnnotations(modelBuilder);
modelBuilder.Entity <Patriarch>().HasData(
new { Id = HierarchyId.GetRoot(), Name = "Eddard Stark" },
new { Id = HierarchyId.Parse("/1/"), Name = "Robb Stark" },
new { Id = HierarchyId.Parse("/2/"), Name = "Jon Snow" });
}
public Block AddRoot()
{
Block systemRoot = new Block()
{
Id = Guid.NewGuid(), BlockName = "_SystemRoot", Path = HierarchyId.GetRoot()
};
context.Blocks.Add(systemRoot);
return(systemRoot);
}
public void Parse_can_translate()
{
var results = Enumerable.ToList(
from p in _db.Patriarchy
where p.Id == HierarchyId.GetRoot()
select HierarchyId.Parse(p.Id.ToString()));
Assert.Equal(
condense(@"SELECT hierarchyid::Parse([p].[Id].ToString()) FROM [Patriarchy] AS [p] WHERE [p].[Id] = '/'"),
condense(_db.Sql));
Assert.Equal(new[] { HierarchyId.Parse("/") }, results);
}
public void GetAncestor_3_can_translate()
{
var results = Enumerable.ToList(
from p in _db.Patriarchy
where p.Id.GetLevel() == 3
select p.Id.GetAncestor(3));
Assert.Equal(
condense(@"SELECT [p].[Id].GetAncestor(3) FROM [Patriarchy] AS [p] WHERE [p].[Id].GetLevel() = CAST(3 AS smallint)"),
condense(_db.Sql));
Assert.All(results, h => Assert.Equal(HierarchyId.GetRoot(), h));
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
=> modelBuilder.Entity <Patriarch>()
.HasData(
new Patriarch {
Id = HierarchyId.GetRoot(), Name = "Abraham"
},
new Patriarch {
Id = HierarchyId.Parse("/1/"), Name = "Isaac"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/"), Name = "Jacob"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/1/"), Name = "Reuben"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/2/"), Name = "Simeon"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/3/"), Name = "Levi"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/4/"), Name = "Judah"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/5/"), Name = "Issachar"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/6/"), Name = "Zebulun"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/7/"), Name = "Dan"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/8/"), Name = "Naphtali"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/9/"), Name = "Gad"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/10/"), Name = "Asher"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/11.1/"), Name = "Ephraim"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/11.2/"), Name = "Manasseh"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/12/"), Name = "Benjamin"
});
private static Dictionary <MethodInfo, string> GetRenamedMethodFunctions()
{
var result = new Dictionary <MethodInfo, string>();
result.Add(GetStaticMethod(() => HierarchyId.GetRoot()), "HierarchyIdGetRoot");
result.Add(GetStaticMethod(() => HierarchyId.Parse(default(string))), "HierarchyIdParse");
result.Add(GetInstanceMethod((HierarchyId h) => h.GetAncestor(default(int))), "GetAncestor");
result.Add(
GetInstanceMethod((HierarchyId h) => h.GetDescendant(default(HierarchyId), default(HierarchyId))), "GetDescendant");
result.Add(GetInstanceMethod((HierarchyId h) => h.GetLevel()), "GetLevel");
result.Add(GetInstanceMethod((HierarchyId h) => h.IsDescendantOf(default(HierarchyId))), "IsDescendantOf");
result.Add(
GetInstanceMethod((HierarchyId h) => h.GetReparentedValue(default(HierarchyId), default(HierarchyId))),
"GetReparentedValue");
return(result);
}
private static IEnumerable <MethodInfo> GetSupportedMethods()
{
yield return(GetStaticMethod(() => HierarchyId.GetRoot()));
yield return(GetStaticMethod(() => HierarchyId.Parse(default(string))));
yield return(GetInstanceMethod((HierarchyId h) => h.GetAncestor(default(int))));
yield return(GetInstanceMethod((HierarchyId h) => h.GetDescendant(default(HierarchyId), default(HierarchyId))));
yield return(GetInstanceMethod((HierarchyId h) => h.GetLevel()));
yield return(GetInstanceMethod((HierarchyId h) => h.IsDescendantOf(default(HierarchyId))));
yield return(GetInstanceMethod((HierarchyId h) => h.GetReparentedValue(default(HierarchyId), default(HierarchyId))));
}
public void HierarchyId_get_ancestor_of_level_is_root()
{
var results = Enumerable.ToList(
from p in _db.Patriarchy
where p.Id.GetAncestor(p.Id.GetLevel()) == HierarchyId.GetRoot() // HierarchyId.Parse("/1/") // HierarchyId.Parse(p.Id.ToString()).GetAncestor(HierarchyId.Parse(p.Id.ToString()).GetLevel())
select p.Name);
Assert.Equal(
condense(@"SELECT [p].[Name] FROM [Patriarchy] AS [p] WHERE [p].[Id].GetAncestor(CAST([p].[Id].GetLevel() AS int)) = '/'"),
condense(_db.Sql));
var all = Enumerable.ToList(
from p in _db.Patriarchy
select p.Name);
Assert.Equal(all, results);
}
public void Aggregates_including_nulls_equalTo_nonNull()
{
var hid = HierarchyId.GetRoot();
var collection = new[] { (HierarchyId)null, (HierarchyId)null, HierarchyId.GetRoot(), HierarchyId.GetRoot(), };
var min = collection.Min();
var max = collection.Max();
Assert.True(hid == min);
Assert.True(min == hid);
Assert.False(hid != min);
Assert.False(min != hid);
Assert.True(hid == max);
Assert.True(max == hid);
Assert.False(hid != max);
Assert.False(max != hid);
}
public Block AppendSubservice(string ns)
{
Block systemRoot = context.Blocks.SingleOrDefault(x => x.Path == HierarchyId.GetRoot());
if (systemRoot == null)
{
systemRoot = AddRoot();
}
var subservice = new Block {
Id = Guid.NewGuid(), BlockName = ns, Path = GetAppendPath(systemRoot.Path)
};
context.Blocks.Add(subservice);
context.SaveChanges();
return(subservice);
}
public static void GetPropagatorResultForPrimitiveType_outputs_expected_results_for_basic_types()
{
Check_result_for_basic_type(PrimitiveTypeKind.Binary, new Byte[0]);
Check_result_for_basic_type(PrimitiveTypeKind.Boolean, default(Boolean));
Check_result_for_basic_type(PrimitiveTypeKind.Byte, default(Byte));
Check_result_for_basic_type(PrimitiveTypeKind.DateTime, default(DateTime));
Check_result_for_basic_type(PrimitiveTypeKind.Time, default(TimeSpan));
Check_result_for_basic_type(PrimitiveTypeKind.DateTimeOffset, default(DateTimeOffset));
Check_result_for_basic_type(PrimitiveTypeKind.Decimal, default(Decimal));
Check_result_for_basic_type(PrimitiveTypeKind.Double, default(Double));
Check_result_for_basic_type(PrimitiveTypeKind.Guid, default(Guid));
Check_result_for_basic_type(PrimitiveTypeKind.Int16, default(Int16));
Check_result_for_basic_type(PrimitiveTypeKind.Int32, default(Int32));
Check_result_for_basic_type(PrimitiveTypeKind.Int64, default(Int64));
Check_result_for_basic_type(PrimitiveTypeKind.Single, default(Single));
Check_result_for_basic_type(PrimitiveTypeKind.SByte, default(SByte));
Check_result_for_basic_type(PrimitiveTypeKind.String, string.Empty);
Check_result_for_basic_type(PrimitiveTypeKind.HierarchyId, HierarchyId.GetRoot());
}
public void Null_against_nonNull()
{
var hid = HierarchyId.GetRoot();
Assert.False(hid == (HierarchyId)null);
Assert.False((HierarchyId)null == hid);
Assert.True(hid != (HierarchyId)null);
Assert.True((HierarchyId)null != hid);
Assert.False(hid > (HierarchyId)null);
Assert.False((HierarchyId)null > hid);
Assert.False(hid >= (HierarchyId)null);
Assert.False((HierarchyId)null >= hid);
Assert.False(hid < (HierarchyId)null);
Assert.False((HierarchyId)null < hid);
Assert.False(hid <= (HierarchyId)null);
Assert.False((HierarchyId)null <= hid);
}
public static SqlHierarchyId GetRoot() => new SqlHierarchyId(HierarchyId.GetRoot());
public IQueryable <DepartmentEntity> GetImmediateRootChilds()
{
return(Entities.Where(x => x.Node.GetAncestor(1) == HierarchyId.GetRoot()));
}
private DepartmentEntity GetRoot()
{
return(Entities.First(x => x.Node == HierarchyId.GetRoot()));
}
public void GetReparentedValue_returns_null_when_newRoot_is_null()
=> Assert.Null(HierarchyId.Parse("/1/").GetReparentedValue(HierarchyId.GetRoot(), newRoot: null));
public override void Up()
{
AddColumn(
"MigrationsCustomers", "hierarchyid_col",
c => c.HierarchyId(nullable: false, defaultValue: HierarchyId.GetRoot()));
}
public async Task <List <HierarchyId> > DeleteDetailWithDescendantsAsync(
int detailId,
int?parentDetailId)
{
List <DetailRelation> childRelationsToDelete = null;
await using (var transaction = await _context.Database.BeginTransactionAsync())
{
List <HierarchyId> parentHierarchyIds = null;
if (parentDetailId != null)
{
parentHierarchyIds = await GetDetailHierarchyIdsAsync(parentDetailId.Value);
}
else
{
parentHierarchyIds = new List <HierarchyId>
{
HierarchyId.GetRoot()
};
}
var detailRelations = await _context.DetailRelations
.AsNoTracking()
.Where(x => x.DetailId == detailId)
.ToListAsync()
.ConfigureAwait(false);
var ancestorRelationsToDelete = new List <DetailRelation>();
detailRelations.ForEach(detailRelation =>
{
if (parentHierarchyIds.Contains(
detailRelation.HierarchyId.GetAncestor(1)))
{
ancestorRelationsToDelete.Add(detailRelation);
}
});
var ancestorHierarchyIdsToDelete = ancestorRelationsToDelete
.Select(x => x.HierarchyId)
.ToList();
IQueryable <DetailRelation> childRelationsToDeleteQuery = _context.DetailRelations
.Where(x => false);
ancestorHierarchyIdsToDelete.ForEach(ancestorHierarchyId =>
{
var queryPart = _context.DetailRelations
.Where(x => x.HierarchyId
.IsDescendantOf(ancestorHierarchyId));
childRelationsToDeleteQuery = childRelationsToDeleteQuery.Concat(queryPart);
});
childRelationsToDelete = await childRelationsToDeleteQuery
.ToListAsync()
.ConfigureAwait(false);
// To address: For some reason added DetailRelations are being tracked by the context
// if use RemoveRange method, then delete query fails or don't work properly
//_context.DetailRelations.RemoveRange(childRelationsToDelete);
childRelationsToDelete.ForEach(x =>
{
var entry = _context.Entry(x);
entry.State = EntityState.Deleted;
});
await _context.SaveChangesAsync().ConfigureAwait(false);
var detailIdsOfDeletedRelations = childRelationsToDelete
.Select(x => x.DetailId)
.Distinct()
.ToList();
var detailIdsToNotDelete = await _context.DetailRelations
.Where(x => detailIdsOfDeletedRelations.Contains(x.DetailId))
.Select(x => x.DetailId)
.Distinct()
.ToListAsync()
.ConfigureAwait(false);
var detailsIdsToRemove = detailIdsOfDeletedRelations
.Except(detailIdsToNotDelete)
.ToList();
if (detailsIdsToRemove.Any())
{
var detailsToRemove = _context.Details
.Where(x => detailsIdsToRemove.Contains(x.DetailId));
_context.Details.RemoveRange(detailsToRemove);
await _context.SaveChangesAsync().ConfigureAwait(false);
}
await transaction.CommitAsync().ConfigureAwait(false);
}
var resultListOfHierarchyIds = childRelationsToDelete?
.Select(x => x.HierarchyId).ToList();
return(resultListOfHierarchyIds);
}
public async Task <List <DetailInTreeView> > AddParentDetailAsync(string detailName)
{
List <DetailInTreeView> resultListOfDetails = null;
await using (var transaction = await _context.Database.BeginTransactionAsync())
{
var retrievedDetail =
await _context.Details
.AsNoTracking()
.SingleOrDefaultAsync(x => x.Name == detailName)
.ConfigureAwait(false);
// Handle case when there is already a detail with such name in db
if (retrievedDetail != null)
{
var existedDetailRelations = await _context.DetailRelations
.AsNoTracking()
.Where(x => x.DetailId == retrievedDetail.DetailId)
.ToListAsync()
.ConfigureAwait(false);
var isRootDetail = existedDetailRelations.Any(x => x.Count == null);
if (isRootDetail)
{
var exceptionMessage = $"Detail with name \'{detailName}\' " +
$"\n\ris already added as parent detail!";
throw new BusinessLogicException(exceptionMessage);
}
var existedDetailRelation = existedDetailRelations.FirstOrDefault();
var existedChildRelations = await _context.DetailRelations
.AsNoTracking()
.Where(x => x.HierarchyId
.IsDescendantOf(existedDetailRelation.HierarchyId))
.ToListAsync()
.ConfigureAwait(false);
var parentHierarchyIdToChange = existedDetailRelation.HierarchyId.GetAncestor(1);
var newParentHierarchyId = HierarchyId.GetRoot();
var childRelationsToAdd = new List <DetailRelation>();
existedChildRelations.ForEach(x =>
{
childRelationsToAdd
.Add(
new DetailRelation
{
DetailId = x.DetailId,
HierarchyId = x.HierarchyId
.GetReparentedValue(parentHierarchyIdToChange, newParentHierarchyId),
Count = x.DetailId == retrievedDetail.DetailId ? null : x.Count
});
});
_context.DetailRelations
.AddRange(childRelationsToAdd);
await _context.SaveChangesAsync().ConfigureAwait(false);
var hierarchyIdsOfAddedRelations =
childRelationsToAdd.Select(x => x.HierarchyId);
resultListOfDetails = await _context.DetailRelations
.AsNoTracking()
.Include(x => x.Detail)
.Where(x => hierarchyIdsOfAddedRelations.Contains(x.HierarchyId))
.Select(x => new DetailInTreeView
{
DetailId = x.DetailId,
Name = x.Detail.Name,
Count = x.Count,
HierarchyLevel = x.HierarchyId
})
.ToListAsync()
.ConfigureAwait(false);
}
// Handle case when there is no detail with such name in db
if (retrievedDetail == null)
{
var addedDetail = _context.Details.Add(
new Detail
{
Name = detailName
});
await _context.SaveChangesAsync().ConfigureAwait(false);
var hierarchyIdToAdd = HierarchyId.Parse($"/{addedDetail.Entity.DetailId}/");
var addedRelation = _context.DetailRelations.Add(
new DetailRelation
{
DetailId = addedDetail.Entity.DetailId,
Count = null,
HierarchyId = hierarchyIdToAdd
});
await _context.SaveChangesAsync().ConfigureAwait(false);
resultListOfDetails = new List <DetailInTreeView>
{
new DetailInTreeView
{
DetailId = addedDetail.Entity.DetailId,
Name = addedDetail.Entity.Name,
Count = addedRelation.Entity.Count,
HierarchyLevel = addedRelation.Entity.HierarchyId
}
};
}
await transaction.CommitAsync().ConfigureAwait(false);
}
return(resultListOfDetails);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity <Patriarch>()
.HasData(
new Patriarch {
Id = HierarchyId.GetRoot(), Name = "Abraham"
},
new Patriarch {
Id = HierarchyId.Parse("/1/"), Name = "Isaac"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/"), Name = "Jacob"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/1/"), Name = "Reuben"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/2/"), Name = "Simeon"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/3/"), Name = "Levi"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/4/"), Name = "Judah"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/5/"), Name = "Issachar"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/6/"), Name = "Zebulun"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/7/"), Name = "Dan"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/8/"), Name = "Naphtali"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/9/"), Name = "Gad"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/10/"), Name = "Asher"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/11.1/"), Name = "Ephraim"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/11.2/"), Name = "Manasseh"
},
new Patriarch {
Id = HierarchyId.Parse("/1/1/12/"), Name = "Benjamin"
});
modelBuilder.Entity <ConvertedPatriarch>(b =>
{
b.Property(e => e.HierarchyId)
.HasConversion(v => HierarchyId.Parse(v), v => v.ToString());
b.HasData(
new ConvertedPatriarch {
Id = 1, HierarchyId = HierarchyId.GetRoot().ToString(), Name = "Abraham"
},
new ConvertedPatriarch {
Id = 2, HierarchyId = HierarchyId.Parse("/1/").ToString(), Name = "Isaac"
},
new ConvertedPatriarch {
Id = 3, HierarchyId = HierarchyId.Parse("/1/1/").ToString(), Name = "Jacob"
},
new ConvertedPatriarch {
Id = 4, HierarchyId = HierarchyId.Parse("/1/1/1/").ToString(), Name = "Reuben"
},
new ConvertedPatriarch {
Id = 5, HierarchyId = HierarchyId.Parse("/1/1/2/").ToString(), Name = "Simeon"
},
new ConvertedPatriarch {
Id = 6, HierarchyId = HierarchyId.Parse("/1/1/3/").ToString(), Name = "Levi"
},
new ConvertedPatriarch {
Id = 7, HierarchyId = HierarchyId.Parse("/1/1/4/").ToString(), Name = "Judah"
},
new ConvertedPatriarch {
Id = 8, HierarchyId = HierarchyId.Parse("/1/1/5/").ToString(), Name = "Issachar"
},
new ConvertedPatriarch {
Id = 9, HierarchyId = HierarchyId.Parse("/1/1/6/").ToString(), Name = "Zebulun"
},
new ConvertedPatriarch {
Id = 10, HierarchyId = HierarchyId.Parse("/1/1/7/").ToString(), Name = "Dan"
},
new ConvertedPatriarch {
Id = 11, HierarchyId = HierarchyId.Parse("/1/1/8/").ToString(), Name = "Naphtali"
},
new ConvertedPatriarch {
Id = 12, HierarchyId = HierarchyId.Parse("/1/1/9/").ToString(), Name = "Gad"
},
new ConvertedPatriarch {
Id = 13, HierarchyId = HierarchyId.Parse("/1/1/10/").ToString(), Name = "Asher"
},
new ConvertedPatriarch {
Id = 14, HierarchyId = HierarchyId.Parse("/1/1/11.1/").ToString(), Name = "Ephraim"
},
new ConvertedPatriarch {
Id = 15, HierarchyId = HierarchyId.Parse("/1/1/11.2/").ToString(), Name = "Manasseh"
},
new ConvertedPatriarch {
Id = 16, HierarchyId = HierarchyId.Parse("/1/1/12/").ToString(), Name = "Benjamin"
});
});
}
