protected override SirenEntityBuilder AddEntityProperties(SirenEntityBuilder entity, Semester item)
{
return(entity
.WithProperty("Id", item.Id)
.WithProperty("Year", item.Year)
.WithProperty("Term", item.Term));
}
protected override SirenEntityBuilder AddCollectionLinks(SirenEntityBuilder entity)
{
return(entity
.WithLink(new LinkBuilder()
.WithRel("index")
.WithHref(UrlTo(Routes.Index))));
}
protected override SirenEntityBuilder AddCollectionActions(
SirenEntityBuilder entity)
{
Claim c = Context.HttpContext.User.FindFirst(ClaimTypes.Role);
if (c != null && (c.Value.Equals(Roles.Admin) || c.Value.Equals(Roles.Teacher)))
{
entity
.WithAction(new ActionBuilder()
.WithName("add-student-to-class")
.WithTitle("Add Student To Class")
.WithMethod("POST")
.WithHref(Url.AbsoluteRouteUrl(
Routes.ClassParticipantAdd,
new { id = Identifier })
)
.WithType("application/json")
.WithField(new FieldBuilder()
.WithTitle("Number")
.WithName("number")
.WithType("number")));
}
return(entity);
}
protected override SirenEntityBuilder AddEntityProperties(SirenEntityBuilder entity, Course item)
{
return(entity
.WithProperty("id", item.Id)
.WithProperty("name", item.Name)
.WithProperty("acr", item.Acronym));
}
/*
|-----------------------------------------------------------------------
| Collection
|-----------------------------------------------------------------------
*/
protected override SirenEntityBuilder AddCollectionActions(SirenEntityBuilder entity)
{
Claim c = Context.HttpContext.User.FindFirst(ClaimTypes.Role);
if (c != null && c.Value.Equals(Roles.Admin))
{
entity
.WithAction(new ActionBuilder()
.WithName("add-course")
.WithTitle("Add Course")
.WithMethod("POST")
.WithHref(UrlTo(Routes.CourseCreate))
.WithType("application/json")
.WithField(new FieldBuilder()
.WithTitle("Name")
.WithName("name")
.WithType("text"))
.WithField(new FieldBuilder()
.WithTitle("Acronym")
.WithName("acronym")
.WithType("text"))
.WithField(new FieldBuilder()
.WithTitle("Coordinator Number")
.WithName("coordinatorId")
.WithType("number")));
}
return(entity);
}
protected override SirenEntityBuilder AddEntityLinks(SirenEntityBuilder entity, Group item)
{
return(entity
.WithLink(new LinkBuilder()
.WithRel("self")
.WithHref(Url.AbsoluteRouteUrl(Routes.GroupEntry, item.Id))));
}
/*
|-----------------------------------------------------------------------
| Entity
|-----------------------------------------------------------------------
*/
protected override SirenEntityBuilder AddEntityProperties(SirenEntityBuilder entity, Teacher item)
{
return(entity
.WithProperty("number", item.Number)
.WithProperty("name", item.Name)
.WithProperty("email", item.Email));
}
public SirenEntity Collection(PagedList <T> items, ListQueryStringDto query)
{
var entity = new SirenEntityBuilder()
.WithClass(Class)
.WithClass("collection");
AddCollectionProperties(entity, items, query);
foreach (var item in items)
{
var subEntity = SubEntity(item);
var embeddedEntity = subEntity as EmbeddedRepresentationBuilder;
if (embeddedEntity != null)
{
embeddedEntity.WithRel("item");
entity.WithSubEntity(embeddedEntity);
}
}
AddCollectionActions(entity);
AddNavigationLinks(entity, items.TotalPages, query);
AddCollectionLinks(entity);
return(entity.Build());
}
/*
|-----------------------------------------------------------------------
| Entity
|-----------------------------------------------------------------------
*/
protected override SirenEntityBuilder AddEntityProperties(
SirenEntityBuilder entity,
Student item)
=> entity
.WithProperty("number", item.Number)
.WithProperty("name", item.Name)
.WithProperty("email", item.Email);
/*
|-----------------------------------------------------------------------
| Collection
|-----------------------------------------------------------------------
*/
protected override SirenEntityBuilder AddCollectionActions(
SirenEntityBuilder entity)
{
Claim c = Context.HttpContext.User.FindFirst(ClaimTypes.Role);
if (c != null && c.Value.Equals(Roles.Admin))
{
entity
.WithAction(new ActionBuilder()
.WithName("add-student")
.WithTitle("Add Student")
.WithMethod("POST")
.WithHref(UrlTo(Routes.StudentCreate))
.WithType("application/json")
.WithField(new FieldBuilder()
.WithTitle("Number")
.WithName("number")
.WithType("number"))
.WithField(new FieldBuilder()
.WithTitle("Name")
.WithName("name")
.WithType("text"))
.WithField(new FieldBuilder()
.WithTitle("E-mail")
.WithName("email")
.WithType("email"))
.WithField(new FieldBuilder()
.WithTitle("Password")
.WithName("password")
.WithType("password")));
}
return(entity);
}
protected override SirenEntityBuilder AddCollectionActions(SirenEntityBuilder entity)
{
Claim c = Context.HttpContext.User.FindFirst(ClaimTypes.Role);
if (c != null && (c.Value.Equals(Roles.Admin) || c.Value.Equals(Roles.Teacher)))
{
entity
.WithAction(new ActionBuilder()
.WithName("add-group-to-class")
.WithTitle("Add Group to Class")
.WithMethod("POST")
.WithHref(UrlTo(Routes.GroupCreate))
.WithType("application/json")
.WithField(new FieldBuilder()
.WithName("ClassId")
.WithType("hidden")
.WithValue(Identifier.ToString()))
.WithField(new FieldBuilder()
.WithTitle("Number")
.WithName("number")
.WithType("number"))
);
}
return(entity);
}
protected override SirenEntityBuilder AddEntityLinks(SirenEntityBuilder entity, Semester item)
{
return(entity
.WithLink(new LinkBuilder()
.WithRel("self")
.WithHref(Url.AbsoluteRouteUrl(Routes.SemesterEntry, new { Id = item.Id }))));
}
/*
|-----------------------------------------------------------------------
| Entity
|-----------------------------------------------------------------------
*/
protected override SirenEntityBuilder AddEntityProperties(SirenEntityBuilder entity, Class item)
{
return(entity
.WithProperty("id", item.Id)
.WithProperty("name", item.Name)
.WithProperty("maxGroupSize", item.MaxGroupSize)
.WithProperty("autoEnrollment", item.AutoEnrollment));
}
public void SirenEntityBuilder_AddProperty_NullProperty_ExpectEntityWithNullProperty()
{
SirenEntityBuilder builder = new SirenEntityBuilder();
builder.AddProperty("testNullProperty", null);
ISirenEntity entity = builder.Build();
Assert.IsNotNull(entity.Properties);
Assert.IsNull(entity.Properties.testNullProperty);
}
protected override SirenEntityBuilder AddCollectionLinks(
SirenEntityBuilder entity)
{
return(entity
.WithLink(new LinkBuilder()
.WithRel("self")
.WithHref(Url.AbsoluteRouteUrl(RouteList, new { id = Identifier })))
.WithLink(new LinkBuilder()
.WithRel("index")
.WithHref(UrlTo(Routes.Index))));
}
protected override SirenEntityBuilder AddEntityLinks(
SirenEntityBuilder entity,
Student item)
{
return(entity
.WithLink(new LinkBuilder()
.WithRel("self")
.WithHref(Url.ToStudent(Routes.StudentEntry, item.Number)))
.WithLink(new LinkBuilder()
.WithRel(SirenData.REL_STUDENTS_CLASSES)
.WithHref(Url.ToStudent(Routes.StudentClassList, item.Number))));
}
protected override SirenEntityBuilder AddEntityLinks(SirenEntityBuilder entity, Course item)
{
return(entity
.WithLink(new LinkBuilder()
.WithRel("self")
.WithHref(Url.ToCourse(Routes.CourseEntry, item.Id)))
.WithLink(new LinkBuilder()
.WithRel(SirenData.REL_COURSE_CLASSES)
.WithHref(Url.ToCourse(Routes.CourseClassList, item.Id)))
.WithLink(new LinkBuilder()
.WithRel(SirenData.REl_COURSE_COORDINATOR)
.WithHref(Url.ToTeacher(Routes.TeacherEntry, item.CoordinatorId))));
}
public void SirenEntityBuilder_Build_WithParams_ExpectEntityWithParams()
{
string expectedTitle = "test-title";
Uri expectedHref = TestHref;
string expectedType = "test-type";
SirenEntityBuilder builder = new SirenEntityBuilder();
ISirenEntity entity = builder.Build(expectedTitle, expectedHref, expectedType);
Assert.AreEqual(expectedTitle, entity.Title);
Assert.AreEqual(expectedHref, entity.Href);
Assert.AreEqual(expectedType, entity.Type);
}
public void SirenEntityBuilder_AddProperty_NonNullProperties_ExpectEntityWithProperties()
{
IList <string> value1 = new List <string>();
string value2 = "my-value-2";
SirenEntityBuilder builder = new SirenEntityBuilder();
builder.AddProperty("myProp1", value1);
builder.AddProperty("myProp2", value2);
ISirenEntity entity = builder.Build();
Assert.IsNotNull(entity.Properties);
Assert.AreEqual(value1, entity.Properties.myProp1);
Assert.AreEqual(value2, entity.Properties.myProp2);
}
public void SirenEntityBuilder_AddLink_ExpectEntityWithLinks()
{
ISirenLink expectedLink1 = TestHelpers.GetLink("link-1");
ISirenLink expectedLink2 = TestHelpers.GetLink("link-2");
SirenEntityBuilder builder = new SirenEntityBuilder();
builder.AddLink(expectedLink1);
builder.AddLink(expectedLink2);
ISirenEntity entity = builder.Build();
Assert.AreEqual(2, entity.Links.Count());
CollectionAssert.Contains(entity.Links, expectedLink1);
CollectionAssert.Contains(entity.Links, expectedLink2);
}
public void SirenEntityBuilder_AddEntity_ExpectEntityWithEntities()
{
ISirenEntity expectedEntity1 = TestHelpers.GetEntity("entity-1");
ISirenEntity expectedEntity2 = TestHelpers.GetEntity("entity-2");
SirenEntityBuilder builder = new SirenEntityBuilder();
builder.AddEntity(expectedEntity1);
builder.AddEntity(expectedEntity2);
ISirenEntity entity = builder.Build();
Assert.AreEqual(2, entity.Entities.Count());
CollectionAssert.Contains(entity.Entities, expectedEntity1);
CollectionAssert.Contains(entity.Entities, expectedEntity2);
}
public void SirenEntityBuilder_AddClass_Single_ExpectEntityWithClasses()
{
string expectedClass1 = "first-class";
string expectedClass2 = "second-class";
SirenEntityBuilder builder = new SirenEntityBuilder();
builder.AddClass(expectedClass1);
builder.AddClass(expectedClass2);
ISirenEntity entity = builder.Build();
Assert.AreEqual(2, entity.Class.Length);
Assert.Contains(expectedClass1, entity.Class);
Assert.Contains(expectedClass2, entity.Class);
}
public void SirenEntityBuilder_AddRel_Single_ExpectEntityWithRels()
{
string expectedRel1 = "first-rel";
string expectedRel2 = "second-rel";
SirenEntityBuilder builder = new SirenEntityBuilder();
builder.AddRel(expectedRel1);
builder.AddRel(expectedRel2);
ISirenEntity entity = builder.Build();
Assert.AreEqual(2, entity.Rel.Length);
Assert.Contains(expectedRel1, entity.Rel);
Assert.Contains(expectedRel2, entity.Rel);
}
public void SirenEntityBuilder_AddAction_ExpectEntityWithActions()
{
ISirenAction expectedAction1 = TestHelpers.GetAction("action-1");
ISirenAction expectedAction2 = TestHelpers.GetAction("action-2");
SirenEntityBuilder builder = new SirenEntityBuilder();
builder.AddAction(expectedAction1);
builder.AddAction(expectedAction2);
ISirenEntity entity = builder.Build();
Assert.AreEqual(2, entity.Actions.Count());
CollectionAssert.Contains(entity.Actions, expectedAction1);
CollectionAssert.Contains(entity.Actions, expectedAction2);
}
protected override SirenEntityBuilder AddEntityLinks(SirenEntityBuilder entity, Teacher item)
{
return(entity
.WithLink(new LinkBuilder()
.WithRel("self")
.WithHref(Url.ToTeacher(Routes.TeacherEntry, item.Number)))
.WithLink(new LinkBuilder()
.WithRel(SirenData.REL_TEACHERS_CLASSES)
.WithHref(Url.ToTeacher(Routes.TeacherClassList, item.Number)))
.WithLink(new LinkBuilder()
.WithRel(SirenData.REL_TEACHER_COURSES)
.WithHref(Url.AbsoluteRouteUrl(
Routes.TeacherCourseList,
new { number = item.Number }))
));
}
public void SirenEntityBuilder_Build_NothingAdded_ExpectEmptyEntity()
{
SirenEntityBuilder builder = new SirenEntityBuilder();
ISirenEntity entity = builder.Build();
Assert.IsEmpty(entity.Class);
Assert.IsNull(entity.Properties);
Assert.IsEmpty(entity.Entities);
Assert.IsEmpty(entity.Links);
Assert.IsEmpty(entity.Actions);
Assert.IsNull(entity.Title);
Assert.IsEmpty(entity.Rel);
Assert.IsNull(entity.Href);
Assert.IsNull(entity.Type);
}
protected override SirenEntityBuilder AddEntitySubEntities(SirenEntityBuilder entity, Course item)
{
if (item.Coordinator != null)
{
}
entity.WithSubEntity(
(SubEntityBuilder) new EmbeddedRepresentationBuilder()
.WithRel("coordinator")
.WithClass("teacher")
.WithProperty("number", item.Coordinator.Number)
.WithProperty("name", item.Coordinator.Name)
.WithProperty("email", item.Coordinator.Email)
);
return(entity);
}
protected override SirenEntityBuilder AddEntitySubEntities(SirenEntityBuilder entity, Class item)
{
if (item.Semester != null)
{
entity.WithSubEntity(
(SubEntityBuilder) new EmbeddedRepresentationBuilder()
.WithRel("semester")
.WithClass("semester")
.WithProperty("Id", item.Semester.Id)
.WithProperty("Year", item.Semester.Year)
.WithProperty("Term", item.Semester.Term)
);
}
return(entity);
}
/*
|-----------------------------------------------------------------------
| Helpers
|-----------------------------------------------------------------------
*/
protected SirenEntityBuilder AddCollectionProperties(
SirenEntityBuilder entity,
PagedList <T> items,
ListQueryStringDto query)
{
entity
.WithProperty("totalCount", items.TotalCount)
.WithProperty("totalPages", items.TotalPages)
.WithProperty("currentPage", items.CurrentPage)
.WithProperty("pageSize", items.PageSize);
if (!string.IsNullOrEmpty(query.Search))
{
entity.WithProperty("search", query.Search);
}
return(entity);
}
protected override SirenEntityBuilder AddEntitySubEntities(SirenEntityBuilder entity, Group item)
{
if (item.Students != null)
{
item.Students.ForEach(i => {
entity.WithSubEntity(
(SubEntityBuilder) new EmbeddedRepresentationBuilder()
.WithRel("item")
.WithClass("student")
.WithProperty("number", i.Student.Number)
.WithProperty("name", i.Student.Name)
.WithProperty("email", i.Student.Email)
);
});
}
return(entity);
}
