public ActionResult ProcessingTime(int?workgroupId = null, DateTime?month = null,
bool?onlyShowReRouted = null)
{
const int defaultResultSize = 1000;
Workgroup workgroup = null;
if (workgroupId.HasValue)
{
workgroup = _repositoryFactory.WorkgroupRepository.GetNullableById(workgroupId.Value);
}
if (onlyShowReRouted == null)
{
onlyShowReRouted = true;
}
var viewModel = ReportProcessingTimeViewModel.Create(_workgroupService, workgroup, onlyShowReRouted.Value);
if (workgroupId.HasValue && month.HasValue)
{
viewModel.GenerateDisplayTable(_searchService, _repositoryFactory, _workgroupService, workgroupId.Value,
month.Value);
}
if (viewModel.SearchResultsCount == defaultResultSize)
{
Message = "Max size of 1000 reached. Please adjust filters.";
}
return(View(viewModel));
}
public static WorkgroupAddressListModel Create(Workgroup workgroup)
{
Check.Require(workgroup != null);
var viewModel = new WorkgroupAddressListModel { Workgroup = workgroup };
viewModel.WorkgroupAddresses = workgroup.Addresses.Where(a => a.IsActive);
return viewModel;
}
public bool HasWorkgroupAccess(Workgroup workgroup)
{
//return true; //TODO: do the actual check once GetWorkgroups is checked?
string message;
return(HasWorkgroupOrOrganizationAccess(workgroup, null, out message));
}
public Workgroup getWorkgroup(int id)
{
string cmd = "select * from рабочие_группы where ID=@id";
SqlCommand command = new SqlCommand(cmd, connection);
command.Parameters.Add(new SqlParameter("@id", id));
SqlDataReader result = command.ExecuteReader();
Workgroup workgroup = null;
if (result.HasRows)
{
while (result.Read())
{
workgroup = new Workgroup
{
ID = result.GetInt32(0),
name = result.GetString(1)
};
}
return(workgroup);
}
else
{
return(null);
}
}
/// <summary>
///
/// </summary>
/// <param name="bulk">string containing emails or kerb ids</param>
/// <param name="isEmail">is the bulk vale an list of emails or kerb ids?</param>
/// <param name="id">Workgroup Id</param>
/// <param name="role">Role being for people being added</param>
/// <param name="workgroup">workgroup</param>
/// <param name="successCount">how many have already been successfully added</param>
/// <param name="lookupUser">user being added</param>
/// <param name="failCount">count of number not added</param>
/// <param name="duplicateCount"> </param>
/// <param name="notAddedKvp">list of users not added and reason why.</param>
/// <returns></returns>
public int TryBulkLoadPeople(string bulk, bool isEmail, int id, Role role, Workgroup workgroup, int successCount, ref int failCount, ref int duplicateCount, List <KeyValuePair <string, string> > notAddedKvp)
{
const string regexEmailPattern = @"\b[A-Z0-9._-]+@[A-Z0-9][A-Z0-9.-]{0,61}[A-Z0-9]\.[A-Z.]{2,6}\b";
const string regexKerbPattern = @"\b[A-Z0-9]{2,10}\b";
string pattern;
if (isEmail)
{
pattern = regexEmailPattern;
}
else
{
pattern = regexKerbPattern;
}
// Find matches
System.Text.RegularExpressions.MatchCollection matches = System.Text.RegularExpressions.Regex.Matches(bulk, pattern, System.Text.RegularExpressions.RegexOptions.IgnoreCase);
foreach (System.Text.RegularExpressions.Match match in matches)
{
var temp = match.ToString().ToLower();
successCount = TryToAddPeople(id, role, workgroup, successCount, temp, ref failCount, ref duplicateCount, notAddedKvp);
}
return(successCount);
}
public void UpdateDefaultAccountApprover(Workgroup workgroup, bool isDefault, string selectedApprover, string roleId)
{
var existingApprover = _workgroupPermissionRepository.Queryable.SingleOrDefault(a => a.Workgroup == workgroup && a.Role.Id == roleId && a.IsDefaultForAccount);
if (!isDefault)
{
if (existingApprover != null)
{
existingApprover.IsDefaultForAccount = false;
_workgroupPermissionRepository.EnsurePersistent(existingApprover);
}
}
else
{
if (existingApprover != null)
{
if (existingApprover.User.Id != selectedApprover)
{
existingApprover.IsDefaultForAccount = false;
_workgroupPermissionRepository.EnsurePersistent(existingApprover);
var newApprover = _workgroupPermissionRepository.Queryable.Single(a => a.Workgroup == workgroup && a.Role.Id == roleId && !a.IsAdmin && a.User.Id == selectedApprover);
newApprover.IsDefaultForAccount = true;
_workgroupPermissionRepository.EnsurePersistent(newApprover);
}
}
else
{
var newApprover = _workgroupPermissionRepository.Queryable.Single(a => a.Workgroup == workgroup && a.Role.Id == roleId && !a.IsAdmin && a.User.Id == selectedApprover);
newApprover.IsDefaultForAccount = true;
_workgroupPermissionRepository.EnsurePersistent(newApprover);
}
}
}
private static bool IsValidRepoData(Workgroup workgroup)
{
if (!workgroup.ReadonlyEnabled)
{
Log.Warn("Readonly user is not enabled! Repo credentials must be entered into Config.yml.");
return(false);
}
if (workgroup.Username == null)
{
Log.Error("Tableau repo username is null! Repo credentials must be entered into Config.yml.");
return(false);
}
if (workgroup.Password == null)
{
Log.Error("Tableau repo password is null! Repo credentials must be entered into Config.yml.");
return(false);
}
if (workgroup.Connection.Host == null)
{
Log.Error("Tableau repo hostname is null! Repo credentials must be entered into Config.yml.");
return(false);
}
return(true);
}
public ActionResult DeleteConfirmed(string id)
{
Workgroup workgroup = db.Workgroups.Find(id);
db.Workgroups.Remove(workgroup);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public bool IsInRole(Role role, Workgroup workgroup)
{
Check.Require(role != null, "role is required.");
Check.Require(workgroup != null, "workgroup is required.");
var user = _repositoryFactory.UserRepository.Queryable.Where(x => x.Id == _userIdentity.Current).Fetch(x => x.Organizations).Single();
return(workgroup.Permissions.Any(a => a.User == user && a.Role == role));
}
public static Workgroup Workgroup(int?counter)
{
var rtValue = new Workgroup();
rtValue.Name = "Name" + counter.Extra();
rtValue.PrimaryOrganization = CreateValidEntities.Organization(counter);
return(rtValue);
}
private void SaveValue(Workgroup obj)
{
using (var tran = db.BeginTransaction())
{
db.SaveOrUpdate(obj);
db.Flush();
tran.Commit();
}
}
public static WorkgroupAddressListModel Create(Workgroup workgroup)
{
Check.Require(workgroup != null);
var viewModel = new WorkgroupAddressListModel {
Workgroup = workgroup
};
viewModel.WorkgroupAddresses = workgroup.Addresses.Where(a => a.IsActive);
return(viewModel);
}
public ActionResult Edit([Bind(Include = "id,DisplayName")] Workgroup workgroup)
{
if (ModelState.IsValid)
{
db.Entry(workgroup).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(workgroup));
}
public ActionResult CreateWorkgroup(Workgroup workgroup)
{
ViewBag.StepNumber = 1;
var user = GetCurrentUser();
//if(!user.Organizations.Any(a => a.Id == workgroup.PrimaryOrganization.Id))
//{
// ModelState.AddModelError("Workgroup.PrimaryOrganization", "You do not have access to the selected organization");
//}
// takes into account department traversal down
string message;
if (!_securityService.HasWorkgroupOrOrganizationAccess(null, workgroup.PrimaryOrganization, out message))
{
ModelState.AddModelError("Workgroup.PrimaryOrganization", "You do not have access to the selected organization");
}
if (workgroup.Administrative && workgroup.SyncAccounts)
{
ModelState.AddModelError("Workgroup.Administrative", "Can not have both Administrative and Sync Accounts selected.");
}
if (workgroup.IsFullFeatured && !workgroup.Administrative)
{
ModelState.AddModelError("Workgroup.Administrative", "If Full Featured, workgroup must be administrative.");
}
if (workgroup.Administrative && !string.IsNullOrEmpty(workgroup.NotificationEmailList))
{
ModelState.AddModelError("Workgroup.NotificationEmailList", "Notification email list will not do anything for an administrative group.");
}
if (workgroup.Administrative && workgroup.DoNotInheritPermissions)
{
ModelState.AddModelError("Workgroup.DoNotInheritPermissions", "Can not have both Administrative and Do Not Inherit Permissions selected.");
}
if (!ModelState.IsValid)
{
var model = WorkgroupModifyModel.Create(user, _queryRepositoryFactory);
model.Workgroup = workgroup;
return(View(model));
}
var createdWorkgroup = _workgroupService.CreateWorkgroup(workgroup, null);
Message = string.Format("{0} workgroup was created",
createdWorkgroup.Name);
return(this.RedirectToAction(a => a.AddSubOrganizations(createdWorkgroup.Id)));
}
public ActionResult Create([Bind(Include = "id,DisplayName")] Workgroup workgroup)
{
if (ModelState.IsValid)
{
db.Workgroups.Add(workgroup);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(workgroup));
}
public static WorkgroupAccountModel Create(IRepository repository, Workgroup workgroup, WorkgroupAccount workgroupAccount = null)
{
Check.Require(repository != null, "repo null");
Check.Require(workgroup != null, "workgroup null");
var viewModel = new WorkgroupAccountModel {
Workgroup = workgroup, WorkgroupAccount = workgroupAccount ?? new WorkgroupAccount()
};
viewModel.WorkGroupPermissions = repository.OfType <WorkgroupPermission>().Queryable.Where(a => a.Workgroup == workgroup && (!a.IsAdmin || (a.IsAdmin && a.IsFullFeatured))).ToList();
viewModel.Accounts = workgroup.Organizations.SelectMany(x => x.Accounts).Distinct().ToList();
viewModel.Approvers = viewModel.WorkGroupPermissions.Where(x => x.Role.Id == Role.Codes.Approver).Select(x => x.User).Distinct().ToList();
viewModel.AccountManagers = viewModel.WorkGroupPermissions.Where(x => x.Role.Id == Role.Codes.AccountManager).Select(x => x.User).Distinct().ToList();
viewModel.Purchasers = viewModel.WorkGroupPermissions.Where(x => x.Role.Id == Role.Codes.Purchaser).Select(x => x.User).Distinct().ToList();
if (viewModel.WorkgroupAccount.Approver == null)
{
var approver = repository.OfType <WorkgroupPermission>().Queryable.SingleOrDefault(
a =>
a.Workgroup == workgroup && a.Role.Id == Role.Codes.Approver && !a.IsAdmin &&
a.IsDefaultForAccount);
if (approver != null)
{
viewModel.WorkgroupAccount.Approver = approver.User;
}
}
if (viewModel.WorkgroupAccount.AccountManager == null)
{
var approver = repository.OfType <WorkgroupPermission>().Queryable.SingleOrDefault(
a =>
a.Workgroup == workgroup && a.Role.Id == Role.Codes.AccountManager && !a.IsAdmin &&
a.IsDefaultForAccount);
if (approver != null)
{
viewModel.WorkgroupAccount.AccountManager = approver.User;
}
}
if (viewModel.WorkgroupAccount.Purchaser == null)
{
var approver = repository.OfType <WorkgroupPermission>().Queryable.SingleOrDefault(
a =>
a.Workgroup == workgroup && a.Role.Id == Role.Codes.Purchaser && !a.IsAdmin &&
a.IsDefaultForAccount);
if (approver != null)
{
viewModel.WorkgroupAccount.Purchaser = approver.User;
}
}
return(viewModel);
}
public ActionResult Edit(int id, Workgroup obj)
{
try
{
SaveValue(obj);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public static ReportWorkloadViewModel Create(IRepositoryFactory repositoryFactory, IQueryRepositoryFactory queryRepositoryFactory, IWorkgroupService workgroupService, string userName, Workgroup workgroup)
{
var workgroups = workgroupService.LoadAdminWorkgroups();
var viewModel = new ReportWorkloadViewModel()
{
Workgroups = workgroups,
Workgroup = workgroup
};
return viewModel;
}
public static WorkgroupAccountModel Create(IRepository repository, Workgroup workgroup, WorkgroupAccount workgroupAccount = null)
{
Check.Require(repository != null, "repo null");
Check.Require(workgroup != null, "workgroup null");
var viewModel = new WorkgroupAccountModel { Workgroup = workgroup, WorkgroupAccount = workgroupAccount ?? new WorkgroupAccount()};
viewModel.WorkGroupPermissions = repository.OfType<WorkgroupPermission>().Queryable.Where(a => a.Workgroup == workgroup && (!a.IsAdmin || (a.IsAdmin && a.IsFullFeatured))).ToList();
viewModel.Accounts = workgroup.Organizations.SelectMany(x => x.Accounts).Distinct().ToList();
viewModel.Approvers = viewModel.WorkGroupPermissions.Where(x => x.Role.Id == Role.Codes.Approver).Select(x => x.User).Distinct().ToList();
viewModel.AccountManagers = viewModel.WorkGroupPermissions.Where(x => x.Role.Id == Role.Codes.AccountManager).Select(x => x.User).Distinct().ToList();
viewModel.Purchasers = viewModel.WorkGroupPermissions.Where(x => x.Role.Id == Role.Codes.Purchaser).Select(x => x.User).Distinct().ToList();
if (viewModel.WorkgroupAccount.Approver == null)
{
var approver = repository.OfType<WorkgroupPermission>().Queryable.SingleOrDefault(
a =>
a.Workgroup == workgroup && a.Role.Id == Role.Codes.Approver && !a.IsAdmin &&
a.IsDefaultForAccount);
if (approver != null)
{
viewModel.WorkgroupAccount.Approver = approver.User;
}
}
if (viewModel.WorkgroupAccount.AccountManager == null)
{
var approver = repository.OfType<WorkgroupPermission>().Queryable.SingleOrDefault(
a =>
a.Workgroup == workgroup && a.Role.Id == Role.Codes.AccountManager && !a.IsAdmin &&
a.IsDefaultForAccount);
if (approver != null)
{
viewModel.WorkgroupAccount.AccountManager = approver.User;
}
}
if (viewModel.WorkgroupAccount.Purchaser == null)
{
var approver = repository.OfType<WorkgroupPermission>().Queryable.SingleOrDefault(
a =>
a.Workgroup == workgroup && a.Role.Id == Role.Codes.Purchaser && !a.IsAdmin &&
a.IsDefaultForAccount);
if (approver != null)
{
viewModel.WorkgroupAccount.Purchaser = approver.User;
}
}
return viewModel;
}
public static WorkgroupAddressViewModel Create(Workgroup workgroup, IRepositoryWithTypedId <State, string> stateRepository, bool loadStates = false)
{
Check.Require(workgroup != null);
var viewModel = new WorkgroupAddressViewModel {
Workgroup = workgroup
};
if (loadStates)
{
viewModel.States = stateRepository.GetAll().ToList();
}
return(viewModel);
}
// GET: Workgroups/Delete/5
public ActionResult Delete(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Workgroup workgroup = Workgroup.find(id, false);
if (workgroup == null)
{
return(HttpNotFound());
}
return(View(workgroup));
}
/// <summary>
/// Add the tableau repo database details to the options.
/// </summary>
/// <param name="config"></param>
/// <param name="options"></param>
/// <param name="tableauRoot"></param>
public static bool AddRepoFromWorkgroupYaml(PaletteInsightConfiguration config, string tableauRoot, PaletteInsightAgentOptions options)
{
var workgroupYmlPath = GetWorkgroupYmlPath(tableauRoot);
Workgroup repo = GetRepoFromWorkgroupYaml(workgroupYmlPath, options.PreferPassiveRepository);
if (repo == null)
{
return(false);
}
try
{
if (IsEncrypted(repo.Password))
{
Log.Info("Encrypted readonly password found in workgroup.yml.");
// if (Tableau.getVersionNumber() >= TABLEAU_VERSION_2018_2)
// {
// Log.Warn("Palette Insight cannot decrypt readonly user's password on Tableau Server 2018.2+! Credentials must be provided in Config.yml!");
// return false;
// }
Log.Info("Getting readonly password with tabadmin command.");
repo.Password = Tableau.tabadminRun("get pgsql.readonly_password");
}
options.RepositoryDatabase = new DbConnectionInfo
{
Server = repo.Connection.Host,
Port = repo.Connection.Port,
Username = repo.Username,
Password = repo.Password,
DatabaseName = repo.Connection.DatabaseName
};
if (config.TableauRepo != null)
{
Log.Warn("Ignoring Tableau repo settings from config.yml.");
}
return(true);
}
catch (Exception e)
{
Log.Error(e, "Failed to acquire Tableau repo connection details! Exception: ");
}
return(false);
}
protected void btnAddWorkgroupConfirm_Click(object sender, EventArgs e)
{
Workgroup workgroup = new Workgroup(Global.Core.Workgroups);
workgroup.Name = txtAddWorkgroupName.Text.Trim();
workgroup.CreationDate = DateTime.Now;
workgroup.Insert();
UserWorkgroup userWorkgroup = new UserWorkgroup(Global.Core.UserWorkgroups);
userWorkgroup.IdUser = Global.IdUser.Value;
userWorkgroup.IdWorkgroup = workgroup.Id;
userWorkgroup.Insert();
Response.Redirect(Request.Url.ToString());
}
public ActionResult Workload(int?workgroupId = null)
{
Workgroup workgroup = null;
if (workgroupId.HasValue)
{
workgroup = _repositoryFactory.WorkgroupRepository.GetNullableById(workgroupId.Value);
}
var viewModel = ReportWorkloadViewModel.Create(_repositoryFactory, _queryRepositoryFactory,
_workgroupService, CurrentUser.Identity.Name, workgroup);
if (workgroupId.HasValue)
{
viewModel.GenerateDisplayTable(_reportRepositoryFactory, workgroupId.Value);
}
return(View(viewModel));
}
private void InsertHierarchy()
{
// Parse the id of the parent hierarchy
// from the http request's parameters.
Guid idHierarchy = Guid.Parse(Request.Params["IdHierarchy"]);
// Create a new hierarchy object.
Hierarchy hierarchy = new Hierarchy(Global.Core.Hierarchies);
hierarchy.IdHierarchy = idHierarchy;
hierarchy.Name = Request.Params["Name"];
hierarchy.SetValue("CreationDate", DateTime.Now);
hierarchy.Insert();
// Parse the id of the workgroup where to assign the
// hierarchy to from the http request's parameters.
Guid idWorkgroup;
if (!Guid.TryParse(Request.Params["IdWorkgroup"], out idWorkgroup))
{
Workgroup workgroup = new Workgroup(Global.Core.Workgroups);
workgroup.CreationDate = DateTime.Now;
workgroup.Name = "Default";
workgroup.Insert();
idWorkgroup = workgroup.Id;
UserWorkgroup userWorkgroup = new UserWorkgroup(Global.Core.UserWorkgroups);
userWorkgroup.IdWorkgroup = idWorkgroup;
userWorkgroup.IdUser = Global.IdUser.Value;
userWorkgroup.Insert();
}
WorkgroupHierarchy workgroupHierarchy = new WorkgroupHierarchy(Global.Core.WorkgroupHierarchies);
workgroupHierarchy.IdHierarchy = hierarchy.Id;
workgroupHierarchy.IdWorkgroup = idWorkgroup;
workgroupHierarchy.Insert();
}
public ActionResult ProcessingTimeByRole(int?workgroupId = null, DateTime?startDate = null,
DateTime?endDate = null, string role = "purchaser")
{
const int defaultResultSize = 1000;
Workgroup workgroup = null;
if (workgroupId.HasValue)
{
workgroup = _repositoryFactory.WorkgroupRepository.GetNullableById(workgroupId.Value);
}
if (startDate == null)
{
startDate = DateTime.Now.AddDays(-30);
}
if (endDate == null)
{
endDate = DateTime.Now;
}
var workgroups = _workgroupService.LoadAdminWorkgroups().ToList();
var viewModel = new ReportProcessingTimeByRoleViewModel()
{
Workgroups = workgroups,
Workgroup = workgroup,
Columns =
_searchService.GetOrderTrackingEntitiesByRole(
workgroup == null ? workgroups.ToArray() : new[] { workgroup }, startDate.Value, endDate.Value, role, defaultResultSize),
StartDate = startDate,
EndDate = endDate,
Role = role
};
if (viewModel.Columns.OrderTrackingEntities.Count == defaultResultSize)
{
ErrorMessage = string.Format("Max result size of {0} has been reached. Please refine your filters to show complete results belowS. Graph is accurate regardless of hitting this limit.", defaultResultSize);
}
//viewModel.JsonData = GetTimeReportData(viewModel.Columns);
return(View(viewModel));
}
public ActionResult ProcessingTimeSummary(int?workgroupId = null, DateTime?startDate = null,
DateTime?endDate = null)
{
const int defaultResultSize = 1000;
Workgroup workgroup = null;
if (workgroupId.HasValue)
{
workgroup = _repositoryFactory.WorkgroupRepository.GetNullableById(workgroupId.Value);
}
if (startDate == null)
{
startDate = DateTime.Now.Date.AddDays(-30);
}
if (endDate == null)
{
endDate = DateTime.Now.Date;
}
var workgroups = _workgroupService.LoadAdminWorkgroups().ToList();
var viewModel = new ReportProcessingTimeSummaryViewModel()
{
Workgroups = workgroups,
Workgroup = workgroup,
StartDate = startDate,
EndDate = endDate,
Columns =
_searchService.GetOrderTrackingEntities(
workgroup == null ? workgroups.ToArray() : new[] { workgroup }, startDate.Value, endDate.Value, defaultResultSize),
};
if (viewModel.Columns.OrderTrackingEntities.Count == defaultResultSize)
{
ErrorMessage = string.Format("Max result size of {0} has been reached. Please refine your filters to show complete results. Averages are accurate for the entire set, but not all rows are displayed.", defaultResultSize);
}
viewModel.JsonData = GetTimeReportData(viewModel.Columns);
return(View(viewModel));
}
private void RemoveWorkgroup(Workgroup workgroup, Repository repository)
{
try
{
if (workgroup.IsUsed)
{
workgroup.MarkedForDeletion = true;
}
else
{
if (workgroup.ActiveMembers != null)
{
foreach (var agent in workgroup.ActiveMembers.ToList())
{
workgroup.ActiveMembers.Remove(agent);
}
}
if (workgroup.Utilizations != null && workgroup.Utilizations.Any())
{
foreach (var workgroupUtilization in workgroup.Utilizations.ToList())
{
var utilization = repository.Utilizations.Find(workgroupUtilization.UtilizationId);
if (utilization != null)
{
workgroup.Utilizations.Remove(utilization);
repository.Utilizations.Remove(utilization);
}
}
}
repository.Workgroups.Remove(workgroup);
}
}
catch (Exception exception)
{
_logging.LogException(exception);
_logging.TraceException(exception, "WorkgroupConfigurations Error");
}
}
/// <summary>
/// Create workgroup
/// </summary>
/// <param name="workgroup"></param>
/// <param name="selectedOrganizations"></param>
/// <returns>Created Workgroup</returns>
public Workgroup CreateWorkgroup(Workgroup workgroup, string[] selectedOrganizations)
{
var workgroupToCreate = new Workgroup();
Mapper.Map(workgroup, workgroupToCreate);
workgroupToCreate.PrimaryOrganization = workgroup.PrimaryOrganization;
if (selectedOrganizations != null)
{
workgroupToCreate.Organizations =
_organizationRepository.Queryable.Where(a => selectedOrganizations.Contains(a.Id)).ToList();
}
if (!workgroupToCreate.Organizations.Contains(workgroupToCreate.PrimaryOrganization))
{
workgroupToCreate.Organizations.Add(workgroupToCreate.PrimaryOrganization);
}
// do the initial load on accounts
if (workgroup.SyncAccounts)
{
// workgroupToCreate.Accounts = _repositoryFactory.AccountRepository.Queryable.Where(a => a.OrganizationId == workgroup.PrimaryOrganization.Id).Select(a => new WorkgroupAccount(){Account = a, Workgroup = workgroupToCreate}).ToList();
var accts = _repositoryFactory.AccountRepository.Queryable.Where(a => a.OrganizationId == workgroup.PrimaryOrganization.Id && a.IsActive).ToList();
foreach (var a in accts)
{
workgroupToCreate.AddAccount(new WorkgroupAccount()
{
Account = a
});
}
}
_workgroupRepository.EnsurePersistent(workgroupToCreate);
AddRelatedAdminUsers(workgroupToCreate);
return(workgroupToCreate);
}
public List <Workgroup> GetWorkgroups()
{
List <Workgroup> workgroups = new List <Workgroup>();
string cmd = "select * from рабочие_группы";
SqlCommand command = new SqlCommand(cmd, connection);
SqlDataReader result = command.ExecuteReader();
if (result.HasRows)
{
while (result.Read())
{
Workgroup group = new Workgroup
{
ID = result.GetInt32(0),
name = result.GetString(1)
};
workgroups.Add(group);
}
}
result.Close();
return(workgroups);
}
public ActionResult ProcessingTime(int?workgroupId = null, DateTime?month = null,
bool?onlyShowReRouted = null)
{
Workgroup workgroup = null;
if (workgroupId.HasValue)
{
workgroup = _repositoryFactory.WorkgroupRepository.GetNullableById(workgroupId.Value);
}
if (onlyShowReRouted == null)
{
onlyShowReRouted = true;
}
var viewModel = ReportProcessingTimeViewModel.Create(_workgroupService, workgroup, onlyShowReRouted.Value);
if (workgroupId.HasValue && month.HasValue)
{
viewModel.GenerateDisplayTable(_searchService, _repositoryFactory, _workgroupService, workgroupId.Value,
month.Value);
}
return(View(viewModel));
}
/// <inheritdoc />
public async Task <int> CreateWorkgroupAsync(WorkgroupDto workgroupDto)
{
Workgroup domainWorkgroup = Mapper.Map <Workgroup>(workgroupDto);
domainWorkgroup.OwnerId = UserId;
bool isExist = await _workgroupRepository.IsExistAsync(domainWorkgroup);
if (isExist)
{
throw new CustomException(
string.Format(Messages.Exception_EntityAlreadyExist_Templete,
Messages.Entity_Workgroup));
}
int result = (await _workgroupRepository.AddAsync(domainWorkgroup)).Id;
await _workgroupRepository.SaveChangesAsync();
RoleToWorkgroup roleToWorkgroup = await _workgroupRepository
.AddRoleToWorkgroup(null, domainWorkgroup.Id);
await _workgroupRepository.SaveChangesAsync();
return(domainWorkgroup.Id);
}
public static ReportProcessingTimeViewModel Create(IWorkgroupService workgroupService, Workgroup workgroup, bool onlyShowReRouted)
{
var workgroups = workgroupService.LoadAdminWorkgroups();
var viewModel = new ReportProcessingTimeViewModel()
{
Workgroups = workgroups,
Workgroup = workgroup,
OnlyShowReRouted = onlyShowReRouted,
Columns = new List<ReportProcessingColumns>()
};
return viewModel;
}
public ActionResult Edit(int id, Workgroup workgroup)
{
var workgroupToEdit = _workgroupRepository.GetNullableById(id);
if (workgroupToEdit == null) return RedirectToAction("Index");
AutoMapper.Mapper.Map(workgroup, workgroupToEdit);
if (ModelState.IsValid)
{
_workgroupRepository.EnsurePersistent(workgroupToEdit);
Message = "Workgroup Edited Successfully";
return RedirectToAction("Index");
}
var viewModel = WorkgroupViewModel.Create(Repository);
viewModel.Workgroup = workgroup;
return View(viewModel);
}
public ActionResult Create(Workgroup workgroup)
{
if (ModelState.IsValid)
{
_workgroupRepository.EnsurePersistent(workgroup);
Message = "Workgroup Created Successfully";
return RedirectToAction("Index");
}
var viewModel = WorkgroupViewModel.Create(Repository);
viewModel.Workgroup = workgroup;
return View(viewModel);
}
public void UpdateRelatedPermissions(Workgroup workgroupToEdit, WorkgroupController.WorkgroupChanged whatWasChanged)
{
whatWasChanged.OrganizationsChanged = false;
if (workgroupToEdit.Organizations.Count != whatWasChanged.OriginalSubOrgIds.Count)
{
whatWasChanged.OrganizationsChanged = true;
}
else
{
foreach (var originalSubOrgId in whatWasChanged.OriginalSubOrgIds)
{
if (!workgroupToEdit.Organizations.Any(a => a.Id == originalSubOrgId))
{
whatWasChanged.OrganizationsChanged = true;
break;
}
}
}
if (!workgroupToEdit.IsActive || (whatWasChanged.AdminChanged && workgroupToEdit.Administrative == false))
{
//Delete any related wp
var wps = _workgroupPermissionRepository.Queryable.Where(a => a.ParentWorkgroup == workgroupToEdit).ToList();
foreach (var wp in wps)
{
Check.Require(wp.IsAdmin);
_workgroupPermissionRepository.Remove(wp);
}
if (workgroupToEdit.IsActive)
{
AddRelatedAdminUsers(workgroupToEdit); // we need to get the parent permissions and add them to this workgroup now.
}
}
else
{
if (workgroupToEdit.Administrative)
{
// need to delete any admin workgroup permissions that may have already existed
var wps = _workgroupPermissionRepository.Queryable.Where(a => a.Workgroup == workgroupToEdit && a.IsAdmin).ToList();
foreach (var wp in wps)
{
_workgroupPermissionRepository.Remove(wp);
}
}
if (whatWasChanged.IsFullFeaturedChanged)
{
var wps = _workgroupPermissionRepository.Queryable.Where(a => a.ParentWorkgroup == workgroupToEdit).ToList();
foreach (var wp in wps)
{
Check.Require(wp.IsAdmin);
wp.IsFullFeatured = workgroupToEdit.IsFullFeatured;
_workgroupPermissionRepository.EnsurePersistent(wp);
}
}
//TODO: What about if it is now administrative. I think we have to clear out non admin wps first.
if ((whatWasChanged.AdminChanged && workgroupToEdit.Administrative) ||
(whatWasChanged.OrganizationsChanged) ||
(whatWasChanged.IsActiveChanged && workgroupToEdit.IsActive) ||
(whatWasChanged.DoNotInheritPermissionsChanged))
{
//add/update related wps
AddRelatedAdminUsers(workgroupToEdit);
}
}
//TODO: Test
}
public void UpdateDefaultAccountApprover(Workgroup workgroup, bool isDefault, string selectedApprover, string roleId)
{
var existingApprover = _workgroupPermissionRepository.Queryable.SingleOrDefault(a => a.Workgroup == workgroup && a.Role.Id == roleId && a.IsDefaultForAccount);
if (!isDefault)
{
if (existingApprover != null)
{
existingApprover.IsDefaultForAccount = false;
_workgroupPermissionRepository.EnsurePersistent(existingApprover);
}
}
else
{
if (existingApprover != null)
{
if (existingApprover.User.Id != selectedApprover)
{
existingApprover.IsDefaultForAccount = false;
_workgroupPermissionRepository.EnsurePersistent(existingApprover);
var newApprover = _workgroupPermissionRepository.Queryable.Single(a => a.Workgroup == workgroup && a.Role.Id == roleId && !a.IsAdmin && a.User.Id == selectedApprover);
newApprover.IsDefaultForAccount = true;
_workgroupPermissionRepository.EnsurePersistent(newApprover);
}
}
else
{
var newApprover = _workgroupPermissionRepository.Queryable.Single(a => a.Workgroup == workgroup && a.Role.Id == roleId && !a.IsAdmin && a.User.Id == selectedApprover);
newApprover.IsDefaultForAccount = true;
_workgroupPermissionRepository.EnsurePersistent(newApprover);
}
}
}
/*
* Dev Data
*/
private static void InsertData(ISession session)
{
//Now insert new data
var scott = new User("postit") { FirstName = "Scott", LastName = "Kirkland", Email = "*****@*****.**", IsActive = true };
var approverUser = new User("approver") { FirstName = "Approver", LastName = "Approver", Email = "*****@*****.**", IsActive = true };
var acctMgrUser = new User("acctmgr") { FirstName = "Account", LastName = "Manager", Email = "*****@*****.**", IsActive = true };
var alan = new User("anlai") { FirstName = "Alan", LastName = "Lai", Email = "*****@*****.**", IsActive = true };
var ken = new User("taylorkj") { FirstName = "Ken", LastName = "Taylor", Email = "*****@*****.**", IsActive = true };
var chris = new User("cthielen") { FirstName = "Christopher", LastName = "Thielen", Email = "*****@*****.**", IsActive = true };
var scottd = new User("sadyer") { FirstName = "Scott", LastName = "Dyer", Email = "*****@*****.**", IsActive = true };
var jscub = new User("jscub")
{
FirstName = "James",
LastName = "Cubbage",
Email = "*****@*****.**",
IsActive = true
};
var jsylvest = new User("jsylvest")
{
FirstName = "Jason",
LastName = "Sylvestre",
Email = "*****@*****.**",
IsActive = true
};
var admin = session.Load<Role>("AD");
var deptAdmin = session.Load<Role>("DA");
var user = session.Load<Role>("RQ");
var approver = session.Load<Role>("AP");
var acctMgr = session.Load<Role>("AM");
var purchaser = session.Load<Role>("PR");
scott.Organizations.Add(session.Load<Organization>("AANS"));
scott.Organizations.Add(session.Load<Organization>("AAES"));
ken.Organizations.Add(session.Load<Organization>("AANS"));
ken.Organizations.Add(session.Load<Organization>("ABAE"));
scottd.Organizations.Add(session.Load<Organization>("AANS"));
scottd.Organizations.Add(session.Load<Organization>("AAES"));
scottd.Organizations.Add(session.Load<Organization>("AFST"));
chris.Organizations.Add(session.Load<Organization>("AANS"));
chris.Organizations.Add(session.Load<Organization>("AAES"));
chris.Organizations.Add(session.Load<Organization>("AFST"));
jscub.Organizations.Add(session.Load<Organization>("AFST"));
jscub.Organizations.Add(session.Load<Organization>("AAES"));
jsylvest.Organizations.Add(session.Load<Organization>("AFST"));
jsylvest.Organizations.Add(session.Load<Organization>("AAES"));
alan.Organizations.Add(session.Load<Organization>("AANS"));
alan.Organizations.Add(session.Load<Organization>("AAES"));
var testWorkgroup = new Workgroup() { Name = "Test Workgroup", IsActive = true, };
var workGroupAccount = new WorkgroupAccount() { };
workGroupAccount.Account = session.Load<Account>("3-6851000");
testWorkgroup.AddAccount(workGroupAccount);
var workgroupAccountWithUsers = new WorkgroupAccount
{
Account = session.Load<Account>("3-APSO013"),
Approver = approverUser,
AccountManager = acctMgrUser
};
testWorkgroup.AddAccount(workgroupAccountWithUsers);
testWorkgroup.PrimaryOrganization = session.Load<Organization>("AAES");
testWorkgroup.Organizations.Add(session.Load<Organization>("AAES"));
testWorkgroup.Organizations.Add(session.Load<Organization>("APLS"));
// Add a vendor to the test workgroup
var testWorkgroupVendor = new WorkgroupVendor
{
Name = "Office Max Corp.",
City = "Sacramento",
CountryCode = "US",
Line1 = "3 1/2 External Drive",// (get it?)
State = "CA",
Zip = "95616"
};
var testWorkgroupVendor2 = new WorkgroupVendor
{
Name = "Manually Added Vendor Corp.",
City = "Sacramento",
CountryCode = "US",
Line1 = "5 1/4 External Drive",// (get it?)
State = "CA",
Zip = "95816"
};
testWorkgroup.AddVendor(testWorkgroupVendor);
testWorkgroup.AddVendor(testWorkgroupVendor2);
var testWorkgroupAddress = new WorkgroupAddress()
{
Name = "The Office",
Address = "One Shields Ave",
Building = "Mrak",
City = "Davis",
State = "CA",
Zip = "95616",
IsActive = true
};
testWorkgroup.AddAddress(testWorkgroupAddress);
var workgroupPerm = new WorkgroupPermission() { User = scott, Role = deptAdmin, Workgroup = testWorkgroup };
var workgroupPerm2 = new WorkgroupPermission() { User = jsylvest, Role = deptAdmin, Workgroup = testWorkgroup };
var workgroupPerm3 = new WorkgroupPermission() { User = jsylvest, Role = user, Workgroup = testWorkgroup };
var workgroupPerm4 = new WorkgroupPermission() { User = jscub, Role = deptAdmin, Workgroup = testWorkgroup };
var workgroupPerm5 = new WorkgroupPermission() { User = alan, Role = deptAdmin, Workgroup = testWorkgroup };
var workgroupPerm6 = new WorkgroupPermission() { User = chris, Role = acctMgr, Workgroup = testWorkgroup };
var workgroupPerm7 = new WorkgroupPermission() { User = scott, Role = approver, Workgroup = testWorkgroup };
var workgroupPerm8 = new WorkgroupPermission() { User = alan, Role = approver, Workgroup = testWorkgroup };
var shippingType = session.Load<ShippingType>("ST");
var orderType = session.Load<Role>("OR");
var autoApproval = new AutoApproval //Approve anything scott sends to alan under $1000 for the next 2 years
{
TargetUser = scott,
User = alan,
IsActive = true,
Expiration = DateTime.Now.AddYears(2),
LessThan = true,
MaxAmount = 1000.00M
};
var autoApprovalAccount = new AutoApproval //Approve anything from account 3-APSO013 associated with approverUser under $1000 for 2 years
{
Account = session.Load<Account>("3-APSO013"),
User = approverUser,
IsActive = true,
Expiration = DateTime.Now.AddYears(2),
LessThan = true,
MaxAmount = 1000.00M
};
session.Save(testWorkgroup);
session.Save(scott);
session.Save(alan);
session.Save(ken);
session.Save(jscub);
session.Save(chris);
session.Save(scottd);
session.Save(jsylvest);
session.Save(approverUser);
session.Save(acctMgrUser);
session.Save(workgroupPerm);
session.Save(workgroupPerm2);
session.Save(workgroupPerm3);
session.Save(workgroupPerm4);
session.Save(workgroupPerm5);
session.Save(workgroupPerm6);
session.Save(workgroupPerm7);
session.Save(workgroupPerm8);
session.Save(autoApproval);
session.Save(autoApprovalAccount);
Roles.AddUsersToRole(new[] { "postit", "anlai", "cthielen" }, "AD");
Roles.AddUserToRole("anlai", "RQ");
Roles.AddUserToRole("anlai", "DA");
Roles.AddUserToRole("anlai", "AP");
Roles.AddUserToRole("taylorkj", "DA");
Roles.AddUserToRole("postit", "DA");
Roles.AddUserToRole("jscub", "DA");
Roles.AddUserToRole("jsylvest", "DA");
session.Flush(); //Flush out the changes
}
public bool HasAccess(string loginId, Workgroup workgroup)
{
var workgroups = GetWorkgroupsByUser(loginId);
if (workgroups.Contains(workgroup))
{
return true;
}
return false;
}
/// <summary>
/// Create workgroup
/// </summary>
/// <param name="workgroup"></param>
/// <param name="selectedOrganizations"></param>
/// <returns>Created Workgroup</returns>
public Workgroup CreateWorkgroup(Workgroup workgroup, string[] selectedOrganizations)
{
var workgroupToCreate = new Workgroup();
Mapper.Map(workgroup, workgroupToCreate);
workgroupToCreate.PrimaryOrganization = workgroup.PrimaryOrganization;
if(selectedOrganizations != null)
{
workgroupToCreate.Organizations =
_organizationRepository.Queryable.Where(a => selectedOrganizations.Contains(a.Id)).ToList();
}
if(!workgroupToCreate.Organizations.Contains(workgroupToCreate.PrimaryOrganization))
{
workgroupToCreate.Organizations.Add(workgroupToCreate.PrimaryOrganization);
}
// do the initial load on accounts
if (workgroup.SyncAccounts)
{
// workgroupToCreate.Accounts = _repositoryFactory.AccountRepository.Queryable.Where(a => a.OrganizationId == workgroup.PrimaryOrganization.Id).Select(a => new WorkgroupAccount(){Account = a, Workgroup = workgroupToCreate}).ToList();
var accts = _repositoryFactory.AccountRepository.Queryable.Where(a => a.OrganizationId == workgroup.PrimaryOrganization.Id && a.IsActive).ToList();
foreach (var a in accts) workgroupToCreate.AddAccount(new WorkgroupAccount() { Account = a });
}
_workgroupRepository.EnsurePersistent(workgroupToCreate);
AddRelatedAdminUsers(workgroupToCreate);
return workgroupToCreate;
}
public void AddRelatedAdminUsers(Workgroup workgroup)
{
if (!workgroup.Administrative)
{
//if this isn't admin, we want to check if we should add users from admin workgroups
var parentWorkgroupIds = GetParentWorkgroups(workgroup.Id);
foreach (var parentWorkgroupId in parentWorkgroupIds)
{
var parentWorkgroup = _repositoryFactory.WorkgroupRepository.Queryable.Single(a => a.Id == parentWorkgroupId);
foreach (var workgroupPermission in parentWorkgroup.Permissions)
{
if (!_workgroupPermissionRepository.Queryable.Any(a => a.Workgroup == workgroup && a.Role == workgroupPermission.Role && a.User == workgroupPermission.User && a.ParentWorkgroup == parentWorkgroup))
{
Check.Require(workgroupPermission.Role.Id != Role.Codes.Requester);
var wp = new WorkgroupPermission();
wp.Role = workgroupPermission.Role;
wp.User = workgroupPermission.User;
wp.Workgroup = workgroup;
wp.IsAdmin = true;
wp.IsFullFeatured = parentWorkgroup.IsFullFeatured;
wp.ParentWorkgroup = parentWorkgroup;
_workgroupPermissionRepository.EnsurePersistent(wp);
}
}
}
var workgroupPermissionsThatMightNeedToBeRemoved = _workgroupPermissionRepository.Queryable.Where(a => a.Workgroup == workgroup && a.IsAdmin && !parentWorkgroupIds.Contains(a.ParentWorkgroup.Id)).ToList();
foreach (var workgroupPermission in workgroupPermissionsThatMightNeedToBeRemoved)
{
_workgroupPermissionRepository.Remove(workgroupPermission);
}
}
else
{
var wp = _workgroupPermissionRepository.Queryable.Where(a => a.Workgroup == workgroup).ToList();
if (wp.Count > 0)
{
var wpActions =
_workgroupPermissionRepository.Queryable.Where(a => a.ParentWorkgroup == workgroup).Select(
b => new WorkgroupPermissionActions(b, WorkgroupPermissionActions.Actions.Delete)).ToList();
var ids = GetChildWorkgroups(workgroup.Id);
foreach (var adminWP in wp) //Go through each permission in the workgroup
{
Check.Require(adminWP.Role.Id != Role.Codes.Requester);
foreach (var childid in ids)
{
var wpAction =
wpActions.SingleOrDefault(
a =>
a.WorkgroupPermission.Workgroup.Id == childid &&
a.WorkgroupPermission.User == adminWP.User &&
a.WorkgroupPermission.Role == adminWP.Role);
if (wpAction != null)
{
wpAction.Action = WorkgroupPermissionActions.Actions.Nothing;
}
else
{
wpAction = new WorkgroupPermissionActions(new WorkgroupPermission(),
WorkgroupPermissionActions.Actions.Add);
wpAction.WorkgroupPermission.Role = adminWP.Role;
wpAction.WorkgroupPermission.User = adminWP.User;
wpAction.WorkgroupPermission.Workgroup =
_workgroupRepository.Queryable.Single(a => a.Id == childid);
wpAction.WorkgroupPermission.IsAdmin = true;
wpAction.WorkgroupPermission.IsFullFeatured = workgroup.IsFullFeatured;
wpAction.WorkgroupPermission.ParentWorkgroup = workgroup;
wpActions.Add(wpAction);
}
}
}
foreach (var wpAction in wpActions)
{
switch (wpAction.Action)
{
case WorkgroupPermissionActions.Actions.Delete:
_workgroupPermissionRepository.Remove(wpAction.WorkgroupPermission);
break;
case WorkgroupPermissionActions.Actions.Add:
_workgroupPermissionRepository.EnsurePersistent(wpAction.WorkgroupPermission);
break;
default:
break;
}
}
}
}
}
public static Workgroup Workgroup(int? counter)
{
var rtValue = new Workgroup();
rtValue.Name = "Name" + counter.Extra();
rtValue.PrimaryOrganization = CreateValidEntities.Organization(counter);
return rtValue;
}
private OrderModifyModel CreateOrderModifyModel(Workgroup workgroup)
{
var model = new OrderModifyModel
{
Order = new Order(),
Workgroup = workgroup,
Units = _repositoryFactory.UnitOfMeasureRepository.Queryable.Cache().ToList(),
Accounts = _repositoryFactory.WorkgroupAccountRepository.Queryable.Where(x => x.Workgroup.Id == workgroup.Id).Select(x => x.Account).ToList(),
Vendors = _repositoryFactory.WorkgroupVendorRepository.Queryable.Where(x => x.Workgroup.Id == workgroup.Id && x.IsActive).OrderBy(a => a.Name).ToList(),
Addresses = _repositoryFactory.WorkgroupAddressRepository.Queryable.Where(x => x.Workgroup.Id == workgroup.Id && x.IsActive).ToList(),
ShippingTypes = _repositoryFactory.ShippingTypeRepository.Queryable.Cache().ToList(),
Approvers = _repositoryFactory.WorkgroupPermissionRepository.Queryable.Where(x => x.Workgroup.Id == workgroup.Id && x.Role.Id == Role.Codes.Approver && !x.IsAdmin).Select(x => x.User).ToList(),
AccountManagers = _repositoryFactory.WorkgroupPermissionRepository.Queryable.Where(x => x.Workgroup.Id == workgroup.Id && x.Role.Id == Role.Codes.AccountManager && !x.IsAdmin).Select(x => x.User).ToList(),
ConditionalApprovals = workgroup.AllConditionalApprovals,
CustomFields = _repositoryFactory.CustomFieldRepository.Queryable.Where(x => x.Organization.Id == workgroup.PrimaryOrganization.Id && x.IsActive).ToList() //call to list to exec the future batch
};
return model;
}
/*
* Demo Data
*/
private static void InsertDemoData(ISession session)
{
// create the users
var admin = new User("anlai") { FirstName = "Alan", LastName = "Lai", Email = "*****@*****.**", IsActive = true };
var user1 = new User("pjfry") { FirstName = "Philip", LastName = "Fry", Email = "*****@*****.**", IsActive = true };
var user2 = new User("hsimpson") { FirstName = "Homer", LastName = "Simpson", Email="*****@*****.**", IsActive = true};
var user3 = new User("brannigan") { FirstName = "Zapp", LastName = "Brannigan", Email = "*****@*****.**", IsActive = true };
var user4 = new User("awong") { FirstName = "Amy", LastName = "Wong", Email = "*****@*****.**", IsActive = true };
var user5 = new User("zoidberg") { FirstName = "John", LastName = "Zoidberg", Email = "*****@*****.**", IsActive = true };
var user6 = new User("moe") { FirstName = "Moe", LastName = "Szyslak", Email = "*****@*****.**", IsActive = true };
var user7 = new User("burns") { FirstName = "Monty", LastName = "Burns", Email = "*****@*****.**", IsActive = true };
var user8 = new User("flanders") { FirstName = "Ned", LastName = "Flanders", Email = "*****@*****.**", IsActive = true };
var user9 = new User("grimes") { FirstName = "Frank", LastName = "Grimes", Email = "*****@*****.**", IsActive = true };
var user10 = new User("bender") { FirstName = "Bender", LastName = "Rodriguez", Email = "*****@*****.**", IsActive = true };
// setup the workgroup
var org1 = session.Load<Organization>("APLS");
var org2 = session.Load<Organization>("AINF");
var org3 = session.Load<Organization>("ACRU");
var orgset1 = new List<Organization>();
orgset1.Add(org1);
orgset1.Add(org2);
var orgset2 = new List<Organization>();
orgset2.Add(org2);
orgset2.Add(org3);
var workgroup = new Workgroup() { Name = "Legitimate Workgroup, Not a Front", IsActive = true, PrimaryOrganization = org1, Organizations = orgset1};
var acct1 = session.Load<Account>("3-APSAC37");
var acct2 = session.Load<Account>("3-APSM170");
var acct3 = session.Load<Account>("3-APSRSTR"); // has sub account
var acct4 = session.Load<Account>("3-APSM152"); // has sub account
var acct5 = session.Load<Account>("3-APSM326"); // has sub account
workgroup.AddAccount(new WorkgroupAccount() { Account = acct1 });
workgroup.AddAccount(new WorkgroupAccount() { Account = acct3 });
workgroup.AddAccount(new WorkgroupAccount() { Account = acct5 });
workgroup.AddAccount(new WorkgroupAccount() { Account = acct2 });
workgroup.AddAccount(new WorkgroupAccount() { Account = acct4 });
var vendor1 = session.Load<Vendor>("0000247673");
var vendoraddr1 = session.QueryOver<VendorAddress>().Where(a => a.Vendor == vendor1).Take(1).SingleOrDefault();
var wv1 = new WorkgroupVendor() { VendorId = vendor1.Id, VendorAddressTypeCode = vendoraddr1.TypeCode, Name = vendor1.Name, Line1 = vendoraddr1.Line1, City = vendoraddr1.City, State = vendoraddr1.State, Zip = vendoraddr1.Zip, CountryCode = vendoraddr1.CountryCode };
workgroup.AddVendor(wv1);
var vendor2 = session.Load<Vendor>("0000008573");
var vendoraddr2 = session.QueryOver<VendorAddress>().Where(a => a.Vendor == vendor2).Take(1).SingleOrDefault();
var wv2 = new WorkgroupVendor(){VendorId = vendor2.Id, VendorAddressTypeCode = vendoraddr2.TypeCode, Name = vendor2.Name, Line1 = vendoraddr2.Line1, City = vendoraddr2.City, State = vendoraddr2.State, Zip = vendoraddr2.Zip, CountryCode = vendoraddr2.CountryCode};
workgroup.AddVendor(wv2);
var vendor3 = session.Load<Vendor>("0000006849");
var vendoraddr3 = session.QueryOver<VendorAddress>().Where(a => a.Vendor == vendor2).Take(1).SingleOrDefault();
var wv3 = new WorkgroupVendor(){VendorId = vendor3.Id, VendorAddressTypeCode = vendoraddr3.TypeCode, Name = vendor3.Name, Line1 = vendoraddr3.Line1, City = vendoraddr3.City, State = vendoraddr3.State, Zip = vendoraddr3.Zip, CountryCode = vendoraddr3.CountryCode};
workgroup.AddVendor(wv3);
var wv4 = new WorkgroupVendor() { Name = "Legitimate Paper Mill", Line1 = "1 Fake Street.", City = "Davis", State = "CA", Zip = "95616", CountryCode = "US" };
workgroup.AddVendor(wv4);
var wv5 = new WorkgroupVendor() { Name = "Office Supplies", Line1 = "2 Fake Street.", City = "Davis", State = "CA", Zip = "95616", CountryCode = "US" };
workgroup.AddVendor(wv5);
var wv6 = new WorkgroupVendor() { Name = "Loads O Lab Equipment", Line1 = "5 Fake Street.", City = "Davis", State = "CA", Zip = "95616", CountryCode = "US" };
workgroup.AddVendor(wv6);
var addr1 = new WorkgroupAddress() { Name = "128 Fake Hall", Address = "Fake Hall Road", City = "Davis", State = "CA", Zip = "95616" };
workgroup.AddAddress(addr1);
var addr2 = new WorkgroupAddress() { Name = "10 Fake Hall", Address = "Fake Hall Road", City = "Davis", State = "CA", Zip = "95616"};
workgroup.AddAddress(addr2);
var addr3 = new WorkgroupAddress() { Name = "526 Fake Hall", Address = "Fake Hall Road", City = "Davis", State = "CA", Zip = "95616" };
workgroup.AddAddress(addr3);
//setup workgroup permissions
var permission1 = new WorkgroupPermission() { User = user1, Workgroup = workgroup, Role = session.Load<Role>("RQ") };
var permission2 = new WorkgroupPermission() { User = user2, Workgroup = workgroup, Role = session.Load<Role>("AP") };
var permission3 = new WorkgroupPermission() { User = user3, Workgroup = workgroup, Role = session.Load<Role>("AM") };
var permission4 = new WorkgroupPermission() { User = user4, Workgroup = workgroup, Role = session.Load<Role>("PR") };
//var permission5 = new WorkgroupPermission() { User = user5, Workgroup = workgroup, Role = session.Load<Role>("CA") }; // conditional approver
var permission6 = new WorkgroupPermission() { User = user6, Workgroup = workgroup, Role = session.Load<Role>("RQ") };
var permission7 = new WorkgroupPermission() { User = user7, Workgroup = workgroup, Role = session.Load<Role>("AP") };
var permission8 = new WorkgroupPermission() { User = user8, Workgroup = workgroup, Role = session.Load<Role>("AM") };
var permission9 = new WorkgroupPermission() { User = user9, Workgroup = workgroup, Role = session.Load<Role>("PR") };
var permission10 = new WorkgroupPermission() { User = user10, Workgroup = workgroup, Role = session.Load<Role>("RQ") };
workgroup.AddPermission(permission1);
workgroup.AddPermission(permission2);
workgroup.AddPermission(permission3);
workgroup.AddPermission(permission4);
//workgroup.AddPermission(permission5);
workgroup.AddPermission(permission6);
workgroup.AddPermission(permission7);
workgroup.AddPermission(permission8);
workgroup.AddPermission(permission9);
workgroup.AddPermission(permission10);
// create some conditional approvals
var ca1 = new ConditionalApproval() {Workgroup = workgroup, PrimaryApprover = user5, Question = "Is this an IT purchaser?"};
// save all the objects
session.Save(admin);
session.Save(user1);
session.Save(user2);
session.Save(user3);
session.Save(user4);
session.Save(user5);
session.Save(user6);
session.Save(user7);
session.Save(user8);
session.Save(user9);
session.Save(user10);
session.Save(workgroup);
session.Save(ca1);
// generate a minimum of 10 for our target user
for (var i = 0; i < 5; i++)
{
var order = GenderateRandomOrder(workgroup, session.Load<OrderStatusCode>("AP"), session, permission1);
session.Save(order);
}
for (var i = 0; i < 5; i++)
{
var order = GenderateRandomOrder(workgroup, session.Load<OrderStatusCode>("AM"), session, permission1);
session.Save(order);
}
for (var i = 0; i < 3; i++)
{
var order = GenderateRandomOrder(workgroup, session.Load<OrderStatusCode>("PR"), session, permission1);
session.Save(order);
}
for (var i = 0; i < 2; i++)
{
var order = GenderateRandomOrder(workgroup, session.Load<OrderStatusCode>("CN"), session, permission1, excludeUser:permission1);
session.Save(order);
}
// now generate another random 50 orders
for (var i = 0; i < 50; i++)
{
var status = session.QueryOver<OrderStatusCode>().Skip(_random.Next()%4).Take(1).SingleOrDefault();
var order = GenderateRandomOrder(workgroup, status, session, excludeUser:permission1);
session.Save(order);
}
}
/// <summary>
/// Generate Random orders
/// </summary>
/// <param name="users">List of users to select from</param>
/// <param name="vendors">List of vendors to select from</param>
/// <param name="statusCode">Status code to set the order approved through</param>
/// <returns></returns>
private static Order GenderateRandomOrder(Workgroup workgroup, OrderStatusCode statusCode, ISession session, WorkgroupPermission user = null, WorkgroupPermission excludeUser = null )
{
var randomizedPerms = workgroup.Permissions.Select(a => new {Permission = a, Key = Guid.NewGuid()});
var requester = user ?? (excludeUser == null ?
randomizedPerms.Where(a=>a.Permission.Role.Id == "RQ").OrderBy(a => a.Key).Select(a => a.Permission).FirstOrDefault()
: randomizedPerms.Where(a=>a.Permission.Role.Id == "RQ" && a.Permission != excludeUser).OrderBy(a => a.Key).Select(a => a.Permission).FirstOrDefault());
var approver = randomizedPerms.Where(a => a.Permission.Role.Id == "AP" && a.Permission.User.Id !="zoidberg").OrderBy(a => a.Key).Select(a => a.Permission).FirstOrDefault();
var conditionalApprover = session.Load<User>("zoidberg"); //workgroup.Permissions.Where(a => a.User.Id == "zoidberg").FirstOrDefault();
var accountmgr = randomizedPerms.Where(a => a.Permission.Role.Id == "AM").OrderBy(a => a.Key).Select(a => a.Permission).FirstOrDefault();
var purchaser = randomizedPerms.Where(a => a.Permission.Role.Id == "PR").OrderBy(a => a.Key).Select(a => a.Permission).FirstOrDefault();
var order = new Order()
{
Justification = _justifications.Skip(_random.Next() % 5).Take(1).FirstOrDefault(),
OrderType = session.Load<OrderType>("OR"),
Workgroup = workgroup,
Organization = workgroup.PrimaryOrganization,
Vendor = workgroup.Vendors.Skip(_random.Next() % workgroup.Vendors.Count).Take(1).FirstOrDefault(),
Address = workgroup.Addresses.Skip(_random.Next() % workgroup.Addresses.Count).Take(1).FirstOrDefault(),
ShippingType = session.QueryOver<ShippingType>().Skip(_random.Next() % 3).Take(1).SingleOrDefault(),
DeliverTo = "Mr. Smith",
DateNeeded = DateTime.Now.AddDays(_random.Next() % 30),
AllowBackorder = _random.Next() % 2 == 1,
EstimatedTax = 8.89m,
CreatedBy = requester.User,
StatusCode = statusCode
};
order.GenerateRequestNumber();
// add the tracking
order.AddApproval(new Approval() { StatusCode = session.Load<OrderStatusCode>("RQ"), Completed = true, User = requester.User });
order.AddApproval(new Approval() { StatusCode = session.Load<OrderStatusCode>("AP"), Completed = statusCode.Level > 2 , User = approver.User });
order.AddApproval(new Approval() { StatusCode = session.Load<OrderStatusCode>("AM"), Completed = statusCode.Level > 3 , User = accountmgr.User });
order.AddApproval(new Approval() { StatusCode = session.Load<OrderStatusCode>("PR"), Completed = statusCode.Level > 4 , User = purchaser.User });
// add the approvals
var daysBack = ((-1)*(_random.Next()%10)) - 10;
order.AddTracking(new OrderTracking() { User = requester.User, DateCreated = DateTime.Now.AddDays(daysBack), Description = "Order submitted by " + requester.User.FullName, StatusCode = session.Load<OrderStatusCode>("RQ") });
if (statusCode.Level > 2)
{
order.AddTracking(new OrderTracking() { User = approver.User, DateCreated = DateTime.Now.AddDays(daysBack + 1), Description = "Order reviewed by " + approver.User.FullName, StatusCode = session.Load<OrderStatusCode>("AP") });
}
if (statusCode.Level > 3)
{
order.AddTracking(new OrderTracking() { User = accountmgr.User, DateCreated = DateTime.Now.AddDays(daysBack + 3), Description = "Order reviewed by " + accountmgr.User.FullName, StatusCode = session.Load<OrderStatusCode>("AM") });
}
if (statusCode.Level > 4)
{
order.AddTracking(new OrderTracking() { User = purchaser.User, DateCreated = DateTime.Now.AddDays(daysBack + (_random.Next() % 4)+3), Description = "Order reviewed by " + purchaser.User.FullName, StatusCode = session.Load<OrderStatusCode>("PR") });
order.AddTracking(new OrderTracking() { User = purchaser.User, DateCreated = DateTime.Now.AddDays(daysBack + (_random.Next() % 4)+8), Description = "Order marked complete by " + purchaser.User.FullName, StatusCode = session.Load<OrderStatusCode>("CN") });
}
// add the conditional stuff if we feel like it
if (_random.Next() % 2 == 1)
{
order.AddApproval(new Approval() { StatusCode = session.Load<OrderStatusCode>("CA"), Completed = statusCode.Level > 2 , User = conditionalApprover });
if (statusCode.Level > 2)
{
order.AddTracking(new OrderTracking() { User = conditionalApprover, DateCreated = DateTime.Now.AddDays(daysBack + 2), Description = "Order reviewed by " + conditionalApprover.FullName, StatusCode = session.Load<OrderStatusCode>("AP") });
}
}
// add the line items
var numLineItems = (_random.Next()%5) + 1; // minimum of 1 line item
for (var i = 0; i < numLineItems; i++)
{
var item = _items.Skip(_random.Next()%_items.Count()).Take(1).FirstOrDefault();
order.AddLineItem(new LineItem() { Quantity = _random.Next() % 10, UnitPrice = item.Value + (item.Value * ((_random.Next() % 10)+1 / 10)), Unit = "each", Description = item.Key });
}
// account information
var splitType = _random.Next()%2;
if (splitType == 1) {
var numSplits = _random.Next()%2;
var skip = _random.Next()%18;
var accounts = session.QueryOver<Account>().Skip(skip+numSplits>=18 ? 18-numSplits : skip).Take(numSplits);
foreach (var act in accounts.List())
{
order.AddSplit(new Split(){Account = act.Id, Amount = order.Total()/numSplits});
}
}
// set shipping
order.ShippingAmount = order.Total()*.1m;
order.TotalFromDb = order.Total();
return order;
}
public void UpdateRelatedPermissions(Workgroup workgroupToEdit, WorkgroupController.WorkgroupChanged whatWasChanged)
{
whatWasChanged.OrganizationsChanged = false;
if (workgroupToEdit.Organizations.Count != whatWasChanged.OriginalSubOrgIds.Count)
{
whatWasChanged.OrganizationsChanged = true;
}
else
{
foreach (var originalSubOrgId in whatWasChanged.OriginalSubOrgIds)
{
if (!workgroupToEdit.Organizations.Any(a => a.Id == originalSubOrgId))
{
whatWasChanged.OrganizationsChanged = true;
break;
}
}
}
if (!workgroupToEdit.IsActive || (whatWasChanged.AdminChanged && workgroupToEdit.Administrative == false))
{
//Delete any related wp
var wps = _workgroupPermissionRepository.Queryable.Where(a => a.ParentWorkgroup == workgroupToEdit).ToList();
foreach (var wp in wps)
{
Check.Require(wp.IsAdmin);
_workgroupPermissionRepository.Remove(wp);
}
if (workgroupToEdit.IsActive)
{
AddRelatedAdminUsers(workgroupToEdit); // we need to get the parent permissions and add them to this workgroup now.
}
}
else
{
if (workgroupToEdit.Administrative)
{
// need to delete any admin workgroup permissions that may have already existed
var wps = _workgroupPermissionRepository.Queryable.Where(a => a.Workgroup == workgroupToEdit && a.IsAdmin).ToList();
foreach (var wp in wps)
{
_workgroupPermissionRepository.Remove(wp);
}
}
if (whatWasChanged.IsFullFeaturedChanged)
{
var wps = _workgroupPermissionRepository.Queryable.Where(a => a.ParentWorkgroup == workgroupToEdit).ToList();
foreach (var wp in wps)
{
Check.Require(wp.IsAdmin);
wp.IsFullFeatured = workgroupToEdit.IsFullFeatured;
_workgroupPermissionRepository.EnsurePersistent(wp);
}
}
//TODO: What about if it is now administrative. I think we have to clear out non admin wps first.
if ((whatWasChanged.AdminChanged && workgroupToEdit.Administrative) ||
(whatWasChanged.OrganizationsChanged) ||
(whatWasChanged.IsActiveChanged && workgroupToEdit.IsActive) ||
(whatWasChanged.DoNotInheritPermissionsChanged))
{
//add/update related wps
AddRelatedAdminUsers(workgroupToEdit);
}
}
//TODO: Test
}
public ActionResult Delete(int id, Workgroup workgroup)
{
var workgroupToDelete = _workgroupRepository.GetNullableById(id);
if (workgroupToDelete == null) return RedirectToAction("Index");
_workgroupRepository.Remove(workgroupToDelete);
Message = "Workgroup Removed Successfully";
return RedirectToAction("Index");
}
/// <summary>
///
/// </summary>
/// <param name="bulk">string containing emails or kerb ids</param>
/// <param name="isEmail">is the bulk vale an list of emails or kerb ids?</param>
/// <param name="id">Workgroup Id</param>
/// <param name="role">Role being for people being added</param>
/// <param name="workgroup">workgroup</param>
/// <param name="successCount">how many have already been successfully added</param>
/// <param name="lookupUser">user being added</param>
/// <param name="failCount">count of number not added</param>
/// <param name="duplicateCount"> </param>
/// <param name="notAddedKvp">list of users not added and reason why.</param>
/// <returns></returns>
public int TryBulkLoadPeople(string bulk, bool isEmail, int id, Role role, Workgroup workgroup, int successCount, ref int failCount, ref int duplicateCount, List<KeyValuePair<string, string>> notAddedKvp)
{
const string regexEmailPattern = @"\b[A-Z0-9._-]+@[A-Z0-9][A-Z0-9.-]{0,61}[A-Z0-9]\.[A-Z.]{2,6}\b";
const string regexKerbPattern = @"\b[A-Z0-9]{2,10}\b";
string pattern;
if(isEmail)
{
pattern = regexEmailPattern;
}
else
{
pattern = regexKerbPattern;
}
// Find matches
System.Text.RegularExpressions.MatchCollection matches = System.Text.RegularExpressions.Regex.Matches(bulk, pattern, System.Text.RegularExpressions.RegexOptions.IgnoreCase);
foreach(System.Text.RegularExpressions.Match match in matches)
{
var temp = match.ToString().ToLower();
successCount = TryToAddPeople(id, role, workgroup, successCount, temp, ref failCount, ref duplicateCount, notAddedKvp);
}
return successCount;
}
/// <summary>
///
/// </summary>
/// <param name="id">Workgroup Id</param>
/// <param name="role">Role being for people being added</param>
/// <param name="workgroup">workgroup</param>
/// <param name="successCount">how many have already been successfully added</param>
/// <param name="lookupUser">user being added</param>
/// <param name="failCount">count of number not added</param>
/// <param name="notAddedKvp">list of users not added and reason why.</param>
/// <returns></returns>
public int TryToAddPeople(int id, Role role, Workgroup workgroup, int successCount, string lookupUser, ref int failCount, ref int duplicateCount, List<KeyValuePair<string, string>> notAddedKvp)
{
var saveParm = lookupUser;
var user = _userRepository.GetNullableById(lookupUser);
if(user == null)
{
var ldapuser = _searchService.FindUser(lookupUser);
if(ldapuser != null)
{
lookupUser = ldapuser.LoginId;
user = _userRepository.GetNullableById(ldapuser.LoginId);
if(user == null)
{
user = new User(ldapuser.LoginId);
user.Email = ldapuser.EmailAddress;
user.FirstName = ldapuser.FirstName;
user.LastName = ldapuser.LastName;
_userRepository.EnsurePersistent(user);
var emailPrefs = new EmailPreferences(user.Id);
_emailPreferencesRepository.EnsurePersistent(emailPrefs);
}
}
}
if(user == null)
{
//notAddedSb.AppendLine(string.Format("{0} : Not found", saveParm));
notAddedKvp.Add(new KeyValuePair<string, string>(saveParm, "Not found"));
failCount++;
return successCount;
}
if(!_workgroupPermissionRepository.Queryable.Any(a => a.Role == role && a.User == user && a.Workgroup == workgroup && a.IsAdmin== false))
{
var workgroupPermission = new WorkgroupPermission();
workgroupPermission.Role = role;
workgroupPermission.User = _userRepository.GetNullableById(lookupUser);
workgroupPermission.Workgroup = _workgroupRepository.GetNullableById(id);
_workgroupPermissionRepository.EnsurePersistent(workgroupPermission);
if (workgroup.Administrative)
{
var ids = GetChildWorkgroups(workgroup.Id);
foreach (var childid in ids)
{
var childWorkgroup = _workgroupRepository.Queryable.Single(a => a.Id == childid);
if (!_workgroupPermissionRepository.Queryable.Any(a=> a.Workgroup==childWorkgroup && a.Role==role && a.User==user && a.IsAdmin && a.ParentWorkgroup==workgroup))
{
Check.Require(role.Id != Role.Codes.Requester);
var childPermission = new WorkgroupPermission();
childPermission.Role = role;
childPermission.User = workgroupPermission.User;
childPermission.Workgroup = childWorkgroup;
childPermission.IsAdmin = true;
childPermission.IsFullFeatured = workgroup.IsFullFeatured;
childPermission.ParentWorkgroup = workgroup;
_workgroupPermissionRepository.EnsurePersistent(childPermission);
}
}
}
// invalid the cache for the user that was just given permissions
_userIdentity.RemoveUserRoleFromCache(Resources.Role_CacheId, workgroupPermission.User.Id);
successCount++;
}
else
{
//notAddedSb.AppendLine(string.Format("{0} : Is a duplicate", lookupUser));
notAddedKvp.Add(new KeyValuePair<string, string>(lookupUser, "Is a duplicate"));
failCount++;
duplicateCount++;
}
return successCount;
}
/// <summary>
/// Incomplete generation of a finite set of order information
/// </summary>
/// <param name="workgroup"></param>
/// <param name="statusCodes"></param>
/// <param name="session"></param>
/// <returns></returns>
private static List<Order> GenerateTestOrders(Workgroup workgroup, List<OrderStatusCode> statusCodes, ISession session )
{
var orders = new List<Order>();
var requester = statusCodes.Where(a => a.Id == "RQ").First();
var approver = statusCodes.Where(a => a.Id == "AP").First();
var conditional = statusCodes.Where(a => a.Id == "CA").First();
var accountmgr = statusCodes.Where(a => a.Id == "AM").First();
var purchaser = statusCodes.Where(a => a.Id == "PR").First();
var completed = statusCodes.Where(a => a.Id == "CP").First();
var requester1 = workgroup.Permissions.Where(a => a.User.Id == "pjfry").First();
var requester2 = workgroup.Permissions.Where(a => a.User.Id == "moe").First();
var requester3 = workgroup.Permissions.Where(a => a.User.Id == "bender").First();
var approver1 = workgroup.Permissions.Where(a => a.User.Id == "hsimpson").First();
var approver2 = workgroup.Permissions.Where(a => a.User.Id == "zoidberg").First();
var approver3 = workgroup.Permissions.Where(a => a.User.Id == "burns").First();
var accountmgr1 = workgroup.Permissions.Where(a => a.User.Id == "brannigan").First();
var accountmgr2 = workgroup.Permissions.Where(a => a.User.Id == "flanders").First();
var purchaser1 = workgroup.Permissions.Where(a => a.User.Id == "awong").First();
var purchaser2 = workgroup.Permissions.Where(a => a.User.Id == "grimes").First();
// create the aprover level orders
var order = new Order() { Workgroup = workgroup, Organization = workgroup.PrimaryOrganization, StatusCode = approver, CreatedBy = requester1.User };
order.AddTracking(new OrderTracking(){DateCreated = DaysBack(), User = requester1.User, Description = "n/a"});
order.AddApproval(new Approval() { Completed = true, User = requester1.User, StatusCode = requester });
order.AddApproval(new Approval() { Completed = false, User = requester1.User, StatusCode = approver });
order.AddApproval(new Approval() { Completed = false, User = requester1.User, StatusCode = accountmgr });
order.AddApproval(new Approval() { Completed = false, User = requester1.User, StatusCode = purchaser });
orders.Add(order);
order = new Order() { Workgroup = workgroup, Organization = workgroup.PrimaryOrganization, StatusCode = approver, CreatedBy = requester1.User };
order.AddTracking(new OrderTracking() { DateCreated = DaysBack(), User = requester1.User, Description = "n/a" });
order.AddApproval(new Approval() { Completed = true, User = requester1.User, StatusCode = requester });
order.AddApproval(new Approval() { Completed = false, User = requester1.User, StatusCode = approver });
order.AddApproval(new Approval() { Completed = false, User = requester1.User, StatusCode = accountmgr });
order.AddApproval(new Approval() { Completed = false, User = requester1.User, StatusCode = purchaser });
orders.Add(order);
return orders;
}
