private static IEnumerable <Guid> GetOrganisationIds(OrganisationHierarchy organisationHierarchy)
{
var ids = new List <Guid>();
GetOrganisationIds(ids, organisationHierarchy);
return(ids);
}
public void TestLinearOrganisationHierarchy()
{
var parent = _organisationsCommand.CreateTestVerifiedOrganisation(1, null, Guid.NewGuid());
var child = _organisationsCommand.CreateTestVerifiedOrganisation(2, parent, Guid.NewGuid());
var grandchild = _organisationsCommand.CreateTestVerifiedOrganisation(3, child, Guid.NewGuid());
var expected = new OrganisationHierarchy
{
Organisation = parent,
ChildOrganisationHierarchies = new List <OrganisationHierarchy>
{
new OrganisationHierarchy
{
Organisation = child,
ChildOrganisationHierarchies = new List <OrganisationHierarchy>
{
new OrganisationHierarchy
{
Organisation = grandchild,
ChildOrganisationHierarchies = new List <OrganisationHierarchy>()
}
}
}
}
};
AssertHierarchy(expected, _organisationsQuery.GetOrganisationHierarchy(parent.Id));
AssertHierarchy(expected, _organisationsQuery.GetSubOrganisationHierarchy(parent.Id));
AssertHierarchy(expected, _organisationsQuery.GetOrganisationHierarchy(child.Id));
AssertHierarchy(expected.ChildOrganisationHierarchies[0], _organisationsQuery.GetSubOrganisationHierarchy(child.Id));
AssertHierarchy(expected, _organisationsQuery.GetOrganisationHierarchy(grandchild.Id));
AssertHierarchy(expected.ChildOrganisationHierarchies[0].ChildOrganisationHierarchies[0], _organisationsQuery.GetSubOrganisationHierarchy(grandchild.Id));
}
private static IEnumerable <Guid> GetOrganisationsIds(Guid organisationId, OrganisationHierarchy organisationHierarchy)
{
var organisationIds = new List <Guid>();
GetOrganisationsIds(organisationIds, GetChildOrganisationHierarchy(organisationId, organisationHierarchy));
return(organisationIds);
}
private static void GetOrganisationsIds(ICollection <Guid> organisationIds, OrganisationHierarchy organisationHierarchy)
{
organisationIds.Add(organisationHierarchy.Organisation.Id);
foreach (var child in organisationHierarchy.ChildOrganisationHierarchies)
{
GetOrganisationsIds(organisationIds, child);
}
}
private static void AssertHierarchy(OrganisationHierarchy expectedHierarchy, OrganisationHierarchy organisationHierarchy)
{
Assert.AreEqual(expectedHierarchy.Organisation.Id, organisationHierarchy.Organisation.Id);
Assert.AreEqual(expectedHierarchy.ChildOrganisationHierarchies.Count, organisationHierarchy.ChildOrganisationHierarchies.Count);
for (var index = 0; index < expectedHierarchy.ChildOrganisationHierarchies.Count; ++index)
{
AssertHierarchy(expectedHierarchy.ChildOrganisationHierarchies[index], organisationHierarchy.ChildOrganisationHierarchies[index]);
}
}
public static string OrganisationHierarchy(this HtmlHelper htmlHelper, OrganisationHierarchy organisationHierarchy, Organisation currentOrganisation, Func <Organisation, MvcHtmlString> getLink)
{
var ulTagBuilder = new TagBuilder("ul")
{
InnerHtml = htmlHelper.GetOrganisationHierarchyHtml(organisationHierarchy, currentOrganisation, getLink)
};
return(ulTagBuilder.ToString(TagRenderMode.Normal));
}
public void TestSingleOrganisationHierarchy()
{
var organisation = _organisationsCommand.CreateTestVerifiedOrganisation(1, null, Guid.NewGuid());
var expected = new OrganisationHierarchy
{
Organisation = organisation,
ChildOrganisationHierarchies = new List <OrganisationHierarchy>()
};
AssertHierarchy(expected, _organisationsQuery.GetOrganisationHierarchy(organisation.Id));
AssertHierarchy(expected, _organisationsQuery.GetSubOrganisationHierarchy(organisation.Id));
}
public static OrganisationHierarchy WithOrganisation1(this OrganisationHierarchy organisationHierarchy, Organisation organisation1)
{
organisationHierarchy.Organisation1 = organisation1;
return(organisationHierarchy);
}
public static OrganisationHierarchy WithOrganisation(this OrganisationHierarchy organisationHierarchy, Organisation organisation)
{
organisationHierarchy.Organisation = organisation;
return(organisationHierarchy);
}
public static OrganisationHierarchy WithIsActive(this OrganisationHierarchy organisationHierarchy, Boolean isActive)
{
organisationHierarchy.IsActive = isActive;
return(organisationHierarchy);
}
public static OrganisationHierarchy WithHopsBetweenOrgAndAncestor(this OrganisationHierarchy organisationHierarchy, Int32 hopsBetweenOrgAndAncestor)
{
organisationHierarchy.HopsBetweenOrgAndAncestor = hopsBetweenOrgAndAncestor;
return(organisationHierarchy);
}
private static string GetOrganisationHierarchyHtml(this HtmlHelper htmlHelper, OrganisationHierarchy organisationHierarchy, Organisation currentOrganisation, Func <Organisation, MvcHtmlString> getLink)
{
var sb = new StringBuilder();
// Add the list item for this organisaton.
var liTagBuilder = new TagBuilder("li")
{
InnerHtml = htmlHelper.GetOrganisationHtml(organisationHierarchy.Organisation, currentOrganisation, getLink)
};
sb.AppendLine(liTagBuilder.ToString(TagRenderMode.Normal));
// Add any children.
sb.Append(htmlHelper.GetChildOrganisationHierarchiesHtml(organisationHierarchy.ChildOrganisationHierarchies, currentOrganisation, getLink));
return(sb.ToString());
}
/// <summary>
/// Retrieve a OrganisationHierarchy with associated lookups
/// </summary>
/// <param name="currentUser"></param>
/// <param name="user"></param>
/// <param name="appID"></param>
/// <param name="overrideID"></param>
/// <param name="code"></param>
/// <param name="dataRepository"></param>
/// <param name="uow"></param>
/// <returns></returns>
public OrganisationHierarchyVMDC GetOrganisationHierarchy(string currentUser, string user, string appID, string overrideID, string code, IUnitOfWork uow, IRepository <OrganisationHierarchy> dataRepository
, IRepository <Organisation> ancestorOrganisationRepository
, IRepository <Organisation> organisationRepository
, IExceptionManager exceptionManager, IMappingService mappingService)
{
try
{
#region Parameter validation
// Validate parameters
if (string.IsNullOrEmpty(currentUser))
{
throw new ArgumentOutOfRangeException("currentUser");
}
if (string.IsNullOrEmpty(user))
{
throw new ArgumentOutOfRangeException("user");
}
if (string.IsNullOrEmpty(appID))
{
throw new ArgumentOutOfRangeException("appID");
}
if (null == dataRepository)
{
throw new ArgumentOutOfRangeException("dataRepository");
}
if (null == uow)
{
throw new ArgumentOutOfRangeException("uow");
}
if (null == exceptionManager)
{
throw new ArgumentOutOfRangeException("exceptionManager");
}
if (null == mappingService)
{
throw new ArgumentOutOfRangeException("mappingService");
}
#endregion
using (uow)
{
OrganisationHierarchyDC destination = null;
// If code is null then just return supporting lists
if (!string.IsNullOrEmpty(code))
{
// Convert code to Guid
Guid codeGuid = Guid.Parse(code);
// Retrieve specific OrganisationHierarchy
OrganisationHierarchy dataEntity = dataRepository.Single(x => x.Code == codeGuid);
// Convert to data contract for passing through service interface
destination = mappingService.Map <OrganisationHierarchy, OrganisationHierarchyDC>(dataEntity);
}
IEnumerable <Organisation> ancestorOrganisationList = ancestorOrganisationRepository.GetAll(x => x.Name);
IEnumerable <Organisation> organisationList = organisationRepository.GetAll(x => x.Name);
List <OrganisationDC> ancestorOrganisationDestinationList = mappingService.Map <List <OrganisationDC> >(ancestorOrganisationList);
List <OrganisationDC> organisationDestinationList = mappingService.Map <List <OrganisationDC> >(organisationList);
// Create aggregate contract
OrganisationHierarchyVMDC returnObject = new OrganisationHierarchyVMDC();
returnObject.OrganisationHierarchyItem = destination;
returnObject.AncestorOrganisationList = ancestorOrganisationDestinationList;
returnObject.OrganisationList = organisationDestinationList;
return(returnObject);
}
}
catch (Exception e)
{
//Prevent exception from propogating across the service interface
exceptionManager.ShieldException(e);
return(null);
}
}
public static OrganisationHierarchy WithCode(this OrganisationHierarchy organisationHierarchy, Guid code)
{
organisationHierarchy.Code = code;
return(organisationHierarchy);
}
public void TestTreeOrganisationHierarchy()
{
var parent = _organisationsCommand.CreateTestVerifiedOrganisation(1, null, Guid.NewGuid());
var child1 = _organisationsCommand.CreateTestVerifiedOrganisation(2, parent, Guid.NewGuid());
var child2 = _organisationsCommand.CreateTestVerifiedOrganisation(3, parent, Guid.NewGuid());
var grandchild1 = _organisationsCommand.CreateTestVerifiedOrganisation(4, child1, Guid.NewGuid());
var grandchild2 = _organisationsCommand.CreateTestVerifiedOrganisation(5, child1, Guid.NewGuid());
var grandchild3 = _organisationsCommand.CreateTestVerifiedOrganisation(6, child2, Guid.NewGuid());
var expected = new OrganisationHierarchy
{
Organisation = parent,
ChildOrganisationHierarchies = new List <OrganisationHierarchy>
{
new OrganisationHierarchy
{
Organisation = child1,
ChildOrganisationHierarchies = new List <OrganisationHierarchy>
{
new OrganisationHierarchy
{
Organisation = grandchild1,
ChildOrganisationHierarchies = new List <OrganisationHierarchy>()
},
new OrganisationHierarchy
{
Organisation = grandchild2,
ChildOrganisationHierarchies = new List <OrganisationHierarchy>()
}
}
},
new OrganisationHierarchy
{
Organisation = child2,
ChildOrganisationHierarchies = new List <OrganisationHierarchy>
{
new OrganisationHierarchy
{
Organisation = grandchild3,
ChildOrganisationHierarchies = new List <OrganisationHierarchy>()
},
}
}
}
};
AssertHierarchy(expected, _organisationsQuery.GetOrganisationHierarchy(parent.Id));
AssertHierarchy(expected, _organisationsQuery.GetSubOrganisationHierarchy(parent.Id));
AssertHierarchy(expected, _organisationsQuery.GetOrganisationHierarchy(child1.Id));
var child1Hierarchy = (from c in expected.ChildOrganisationHierarchies where c.Organisation.Id == child1.Id select c).Single();
AssertHierarchy(child1Hierarchy, _organisationsQuery.GetSubOrganisationHierarchy(child1.Id));
AssertHierarchy(expected, _organisationsQuery.GetOrganisationHierarchy(child2.Id));
var child2Hierarchy = (from c in expected.ChildOrganisationHierarchies where c.Organisation.Id == child2.Id select c).Single();
AssertHierarchy(child2Hierarchy, _organisationsQuery.GetSubOrganisationHierarchy(child2.Id));
AssertHierarchy(expected, _organisationsQuery.GetOrganisationHierarchy(grandchild1.Id));
var grandchild1Hierarchy = (from c in child1Hierarchy.ChildOrganisationHierarchies where c.Organisation.Id == grandchild1.Id select c).Single();
AssertHierarchy(grandchild1Hierarchy, _organisationsQuery.GetSubOrganisationHierarchy(grandchild1.Id));
AssertHierarchy(expected, _organisationsQuery.GetOrganisationHierarchy(grandchild2.Id));
var grandchild2Hierarchy = (from c in child1Hierarchy.ChildOrganisationHierarchies where c.Organisation.Id == grandchild2.Id select c).Single();
AssertHierarchy(grandchild2Hierarchy, _organisationsQuery.GetSubOrganisationHierarchy(grandchild2.Id));
AssertHierarchy(expected, _organisationsQuery.GetOrganisationHierarchy(grandchild3.Id));
var grandchild3Hierarchy = (from c in child2Hierarchy.ChildOrganisationHierarchies where c.Organisation.Id == grandchild3.Id select c).Single();
AssertHierarchy(grandchild3Hierarchy, _organisationsQuery.GetSubOrganisationHierarchy(grandchild3.Id));
}
IList <Guid> IRecruitersQuery.GetRecruiters(OrganisationHierarchy organisationHierarchy)
{
return(_repository.GetRecruiters(GetOrganisationIds(organisationHierarchy)));
}
private static OrganisationHierarchy GetChildOrganisationHierarchy(Guid organisationId, OrganisationHierarchy organisationHierarchy)
{
if (organisationHierarchy.Organisation.Id == organisationId)
{
return(organisationHierarchy);
}
foreach (var child in organisationHierarchy.ChildOrganisationHierarchies)
{
var childOrganisationHierarchy = GetChildOrganisationHierarchy(organisationId, child);
if (childOrganisationHierarchy != null)
{
return(childOrganisationHierarchy);
}
}
return(null);
}
public static OrganisationHierarchy WithAncestorOrganisationCode(this OrganisationHierarchy organisationHierarchy, Guid ancestorOrganisationCode)
{
organisationHierarchy.AncestorOrganisationCode = ancestorOrganisationCode;
return(organisationHierarchy);
}
/// <summary>
/// Update a OrganisationHierarchy
/// </summary>
/// <param name="currentUser"></param>
/// <param name="user"></param>
/// <param name="appID"></param>
/// <param name="overrideID"></param>
/// <param name="code"></param>
/// <param name="lockID"></param>
/// <param name="dataRepository"></param>
/// <param name="uow"></param>
public void DeleteOrganisationHierarchy(string currentUser, string user, string appID, string overrideID, string code, string lockID, IRepository <OrganisationHierarchy> dataRepository, IUnitOfWork uow, IExceptionManager exceptionManager, IMappingService mappingService)
{
try
{
#region Parameter validation
// Validate parameters
if (string.IsNullOrEmpty(currentUser))
{
throw new ArgumentOutOfRangeException("currentUser");
}
if (string.IsNullOrEmpty(user))
{
throw new ArgumentOutOfRangeException("user");
}
if (string.IsNullOrEmpty(appID))
{
throw new ArgumentOutOfRangeException("appID");
}
if (string.IsNullOrEmpty(code))
{
throw new ArgumentOutOfRangeException("code");
}
if (string.IsNullOrEmpty(lockID))
{
throw new ArgumentOutOfRangeException("lockID");
}
if (null == dataRepository)
{
throw new ArgumentOutOfRangeException("dataRepository");
}
if (null == uow)
{
throw new ArgumentOutOfRangeException("uow");
}
if (null == exceptionManager)
{
throw new ArgumentOutOfRangeException("exceptionManager");
}
if (null == mappingService)
{
throw new ArgumentOutOfRangeException("mappingService");
}
#endregion
using (uow)
{
// Convert string to guid
Guid codeGuid = Guid.Parse(code);
// Find item based on ID
OrganisationHierarchy dataEntity = dataRepository.Single(x => x.Code == codeGuid);
// Delete the item
dataRepository.Delete(dataEntity);
// Commit unit of work
uow.Commit();
}
}
catch (Exception e)
{
//Prevent exception from propogating across the service interface
exceptionManager.ShieldException(e);
}
}
public static OrganisationHierarchy WithOrganisationCode(this OrganisationHierarchy organisationHierarchy, Guid organisationCode)
{
organisationHierarchy.OrganisationCode = organisationCode;
return(organisationHierarchy);
}
/// <summary>
/// Create a OrganisationHierarchy
/// </summary>
/// <param name="currentUser"></param>
/// <param name="user"></param>
/// <param name="appID"></param>
/// <param name="overrideID"></param>
/// <param name="dc"></param>
/// <param name="dataRepository"></param>
/// <param name="uow"></param>
public OrganisationHierarchyVMDC CreateOrganisationHierarchy(string currentUser, string user, string appID, string overrideID, OrganisationHierarchyDC dc, IRepository <OrganisationHierarchy> dataRepository, IUnitOfWork uow, IExceptionManager exceptionManager, IMappingService mappingService)
{
try
{
#region Parameter validation
// Validate parameters
if (string.IsNullOrEmpty(currentUser))
{
throw new ArgumentOutOfRangeException("currentUser");
}
if (string.IsNullOrEmpty(user))
{
throw new ArgumentOutOfRangeException("user");
}
if (string.IsNullOrEmpty(appID))
{
throw new ArgumentOutOfRangeException("appID");
}
if (null == dc)
{
throw new ArgumentOutOfRangeException("dc");
}
if (null == dataRepository)
{
throw new ArgumentOutOfRangeException("dataRepository");
}
if (null == uow)
{
throw new ArgumentOutOfRangeException("uow");
}
if (null == exceptionManager)
{
throw new ArgumentOutOfRangeException("exceptionManager");
}
if (null == mappingService)
{
throw new ArgumentOutOfRangeException("mappingService");
}
#endregion
using (uow)
{
// Create a new ID for the OrganisationHierarchy item
dc.Code = Guid.NewGuid();
// Map data contract to model
OrganisationHierarchy destination = mappingService.Map <OrganisationHierarchyDC, OrganisationHierarchy>(dc);
// Add the new item
dataRepository.Add(destination);
// Commit unit of work
uow.Commit();
// Map model back to data contract to return new row id.
dc = mappingService.Map <OrganisationHierarchy, OrganisationHierarchyDC>(destination);
}
// Create aggregate data contract
OrganisationHierarchyVMDC returnObject = new OrganisationHierarchyVMDC();
// Add new item to aggregate
returnObject.OrganisationHierarchyItem = dc;
return(returnObject);
}
catch (Exception e)
{
//Prevent exception from propogating across the service interface
exceptionManager.ShieldException(e);
return(null);
}
}
public static OrganisationHierarchy WithImmediateParent(this OrganisationHierarchy organisationHierarchy, Boolean immediateParent)
{
organisationHierarchy.ImmediateParent = immediateParent;
return(organisationHierarchy);
}
