public IEnumerable<Application> SearchApplications(SecureSession session, string formId, ApplicationSearchFilter filter, Pagination pagination = null)
{
int applicationId = ((MockSecureSession)session).ApplicationId;
string jsonString = AssemblyResourceReader.ReadAsString(applicationId != 0 ?
string.Format("Test_Data.Applications.APPLICATION-{0}.json", applicationId) : "Test_Data.Applications.APPLICATION-1.json");
List<Application> apps = JsonConvert.DeserializeObject<List<Application>>(jsonString);
if (filter.ApplicationStates != null && filter.ApplicationStates.Count > 0)
{
return apps.Where(a => filter.ApplicationStates.Contains(a.WorkflowState)).ToList();
}
return apps;
}
public void Filter()
{
const string formId = "05";
const string userId = "007";
ApplicationSearchFilter filter = new ApplicationSearchFilter
{
ApplicationStates = new List<string> { "State3" }
};
IEnumerable<Application> apps = this.ApplicationManager.FindApplications(formId, userId, filter);
Assert.AreEqual(1, apps.Count());
}
public void SingleOrgEntitled()
{
if (!Connected)
{
Assert.Inconclusive("Could not connect to database instance '{0}'", Client.GetServer().Instance.Address);
}
ApplicationSearchFilter filter = new ApplicationSearchFilter
{
ApplicationStates = new List<string> { "Submitted", "Received", "Ready for Pickup" },
OrganisationIds = new List<string> { "DC Drycleaners" },
OriginatorApplicationStates = new List<string> { "Submitted", "Received", "Ready for Pickup" }
};
const string userId = "900000000000000000000000"; // Some administrator
ApplicationList applicationList = DataAccess.FindApplications(FORM_ID, userId, false, filter);
Assert.AreEqual(4, applicationList.Count);
}
/// <summary>
/// Retrieve a list of applications based on the search criteria.
/// </summary>
/// <param name="session">An authenticated or unauthenticated session that contains the appropriate form id in the token.</param>
/// <param name="formId">The form id.</param>
/// <param name="filter">The search filter, serialised as JSON.</param>
/// <param name="pagination">The paging information, serialised as JSON.</param>
/// <returns>A list of applications based on the search criteria.</returns>
public IEnumerable<Application> SearchApplications(SecureSession session, string formId, ApplicationSearchFilter filter, Pagination pagination = null)
{
string filterJson = JsonConvert.SerializeObject(filter);
string paginationJson = pagination == null ? null : JsonConvert.SerializeObject(pagination);
string responseString = this.AddTokenAndInvoke(session.Token, new Func<string, string, string, string>(this.client.FindApplications), formId, filterJson, paginationJson);
var template = new
{
success = true,
applications = new Application[0],
pagination = new Pagination()
};
var responseObj = JsonConvert.DeserializeAnonymousType(responseString, template);
return responseObj.applications;
}
public void EntitledUserViewAllDrafts()
{
if (!Connected)
{
Assert.Inconclusive("Could not connect to database instance '{0}'", Client.GetServer().Instance.Address);
}
ApplicationSearchFilter filter = new ApplicationSearchFilter
{
ApplicationStates = new List<string> { "New" },
OrganisationIds = new List<string> { "Benevolent Overlord Organisation", "DC Drycleaners" },
OriginatorApplicationStates = new List<string> { "Submitted", "Received", "Ready for Pickup" }
};
const string userId = "900000000000000000000000"; // Some administrator
ApplicationList applicationList = DataAccess.FindApplications(FORM_ID, userId, true, filter);
Assert.AreEqual(3, applicationList.Count(a => a.Draft));
}
public void PublicUserViewOwnDrafts()
{
if (!Connected)
{
Assert.Inconclusive("Could not connect to database instance '{0}'", Client.GetServer().Instance.Address);
}
ApplicationSearchFilter filter = new ApplicationSearchFilter
{
ApplicationStates = new List<string> { "New" },
OrganisationIds = new List<string> { "Benevolent Overlord Organisation", "DC Drycleaners" },
OriginatorApplicationStates = new List<string> { "Submitted", "Received", "Ready for Pickup" }
};
const string userId = "000000000000000000000001"; // Bruce Wayne
ApplicationList applicationList = DataAccess.FindApplications(FORM_ID, userId, false, filter);
Application app = applicationList.FirstOrDefault(a => a.Draft && a.IsCreatedBy(userId));
Assert.IsNotNull(app);
}
/// <summary>
/// Gets work based on a known transition timespan.
/// </summary>
/// <param name="session">A secure Session.</param>
/// <param name="formId">The form id.</param>
/// <param name="state">The Workflow State.</param>
/// <param name="transition">The Workflow Transision.</param>
/// <param name="work">The work list to update.</param>
private void GetWorkAfterTimespan(SecureSession session, string formId, WorkflowState state, WorkflowTransition transition, UnitOfWorkList<ApplicationWorkItem> work)
{
DateTime? lastTransitionDate = transition.GetKnownTransitionDateTime();
if (lastTransitionDate != null)
{
ApplicationSearchFilter filter = new ApplicationSearchFilter
{
ApplicationStates = new List<string> { state.Name },
StateTransitionDate = new DateTimeRange()
{
To = lastTransitionDate
}
};
// Pagination pagination = new Pagination() { PageIndex = 0, PageSize = 50 };
Pagination pagination = null;
IEnumerable<Application> apps = this.formServiceGateway.SearchApplications(session, formId, filter, pagination);
work.AddRange(apps.Select(app => new ApplicationWorkItem
{
Application = app,
Transition = transition
}).Select(workItem => new UnitOfWork<ApplicationWorkItem>(workItem)));
}
}
/// <summary>
/// Gets work fo all apps in a geven state after a fixed point in time.
/// </summary>
/// <param name="session">A secure Session.</param>
/// <param name="formId">The form id.</param>
/// <param name="state">The Workflow State.</param>
/// <param name="transition">The Workflow Transision.</param>
/// <param name="work">The work list to update.</param>
private void GetWorkAfterDateTime(SecureSession session, string formId, WorkflowState state, WorkflowTransition transition, UnitOfWorkList<ApplicationWorkItem> work)
{
if (transition.ExitStateName == state.Name)
{
return;
}
ApplicationSearchFilter filter = new ApplicationSearchFilter
{
ApplicationStates = new List<string> { state.Name }
};
IEnumerable<Application> apps = null;
if (transition.OnDateTimeCompare == ComparisonType.Value)
{
DateTime? pointInTime = transition.GetOnDateTimeTransitionDateTime();
if (pointInTime != null && pointInTime <= DateTime.Now)
{
apps = this.formServiceGateway.SearchApplications(session, formId, filter, null);
}
}
if (transition.OnDateTimeCompare == ComparisonType.Field && !string.IsNullOrEmpty(transition.OnDateTimeField))
{
var offset = DateTime.Now;
if (!string.IsNullOrEmpty(transition.OnDateTimeOffset))
{
offset = offset.Subtract(transition.OnDateTimeOffset);
}
filter.ApplicationDataDates = new Dictionary<string, DateTimeRange>
{
{ transition.OnDateTimeField, new DateTimeRange() { To = offset } }
};
apps = this.formServiceGateway.SearchApplications(session, formId, filter);
}
if (apps != null)
{
work.AddRange(apps.Select(app => new ApplicationWorkItem
{
Application = app,
Transition = transition
}).Select(workItem => new UnitOfWork<ApplicationWorkItem>(workItem)));
}
}
/// <summary>
/// Gets work for all applicaiotns in the specified state.
/// </summary>
/// <param name="session">A secure Session.</param>
/// <param name="formId">The form id.</param>
/// <param name="state">The Workflow State.</param>
/// <param name="transition">The Workflow Transision.</param>
/// <param name="work">The work list to update.</param>
private void GetAllEventsInState(SecureSession session, string formId, WorkflowState state, WorkflowTransition transition, UnitOfWorkList<ApplicationWorkItem> work)
{
ApplicationSearchFilter filter = new ApplicationSearchFilter
{
ApplicationStates = new List<string> { state.Name }
};
IEnumerable<Application> apps = this.formServiceGateway.SearchApplications(session, formId, filter);
work.AddRange(apps.Select(app => new ApplicationWorkItem
{
Application = app,
Transition = transition
}).Select(workItem => new UnitOfWork<ApplicationWorkItem>(workItem)));
}
/// <summary>
/// Summarises all applications matching the search criteria, grouping them by their workflow state.
/// </summary>
/// <param name="that">The <see cref="ApplicationManager"/> that acts as the "this" instance.</param>
/// <param name="formId">The form / product id.</param>
/// <param name="userId">The user id.</param>
/// <param name="filter">The search filter.</param>
/// <returns>A summary of all applications matching the search criteria, grouping them by their workflow state.</returns>
public static Dictionary<string, int> SummariseApplications(this ApplicationManager that, string formId, string userId, ApplicationSearchFilter filter)
{
IEnumerable<Application> apps = that.FindApplications(formId, userId, filter);
return apps.GroupBy(a => a.WorkflowState).ToDictionary(a => a.Key, b => b.Count());
}
/// <summary>
/// Finds applications matching the search criteria.
/// </summary>
/// <param name="formId">The form / product id.</param>
/// <param name="userId">The user id.</param>
/// <param name="filter">The search filter.</param>
/// <param name="pagination">The paging information. Defaults to <see langword="null"/>.</param>
/// <returns>The applications matching the search criteria.</returns>
public IEnumerable<Application> FindApplications(string formId, string userId, ApplicationSearchFilter filter, Pagination pagination = null)
{
User user = this.userManager.GetUserById(userId);
UserFormAccess access = this.GetAuthorisedStates(formId, user);
SystemEntitlementAccess systemEntitlements = this.entitlementProvider.GetSystemEntitlements(userId);
List<string> assigneeList = access.ImplicitWorkflowStates.ContainsKey(SecurityConstants.AssigneeRoleName) ? access.ImplicitWorkflowStates[SecurityConstants.AssigneeRoleName] : new List<string>();
List<string> originatorList = access.ImplicitWorkflowStates.ContainsKey(SecurityConstants.OriginatorRoleName) ? access.ImplicitWorkflowStates[SecurityConstants.OriginatorRoleName] : new List<string>();
if (filter.ApplicationStates.Count == 0)
{
filter.ApplicationStates = access.ExplicitWorkflowStates;
filter.AssigneeApplicationStates = assigneeList;
filter.OriginatorApplicationStates = originatorList;
}
else
{
List<string> requestedStates = filter.ApplicationStates;
filter.ApplicationStates = requestedStates.Intersect(access.ExplicitWorkflowStates).ToList();
filter.AssigneeApplicationStates = requestedStates.Intersect(assigneeList).ToList();
filter.OriginatorApplicationStates = requestedStates.Intersect(originatorList).ToList();
}
if (filter.ApplicationStates.Count == 0 && filter.OriginatorApplicationStates.Count == 0)
{
return new Application[0];
}
if (filter.ApplicationData != null)
{
for (int i = 0; i < filter.ApplicationData.Count(); i++)
{
var data = filter.ApplicationData.ElementAt(i);
List<string> values = filter.ApplicationData[data.Key].Select(value => value != null ? Regex.Escape(value) : null).ToList();
filter.ApplicationData[data.Key] = values;
}
}
filter.OrganisationIds = user.GetAllOrganisations().Select(o => o.Key).ToList();
List<Application> applications = this.DataAccess.FindApplications(formId, userId, systemEntitlements[SystemEntitlementAccess.VIEW_DRAFT_APPLICATIONS] != AccessLevel.NoAccess, filter, pagination);
List<Application> filtered = applications;
if (filter.ApplicationDataDates == null)
{
return filtered;
}
var dataDates = filter.ApplicationDataDates.Where(x => x.Value != null);
if (!dataDates.Any())
{
return filtered;
}
filtered = new List<Application>();
foreach (KeyValuePair<string, DateTimeRange> dataDate in dataDates)
{
foreach (var application in applications)
{
DateTime date;
bool isDate = DateTime.TryParse(application.ApplicationData.GetValue<string>(dataDate.Key), out date);
var dtFrom = dataDate.Value.From ?? DateTime.MinValue;
var dtTo = dataDate.Value.To ?? DateTime.MaxValue;
if (isDate && date >= dtFrom && date <= dtTo)
{
filtered.Add(application);
}
}
}
return filtered;
}
