public async Task <PermissionTemplateDTO> Handle(EditPermissionTemplateCommand command)
{
PermissionTemplateProjection template = await _context.PermissionTemplateProjection.SingleOrDefaultAsync(a => a.Id == command.Input.Id);
if (template == null)
{
return(new PermissionTemplateDTO());
}
template.Name = command.Input.Name;
template.TemplatePermissions = command.Input.TemplatePermissions.Any()
? JsonConvert.SerializeObject(command.Input.TemplatePermissions) : JsonConvert.SerializeObject(new Dictionary <Guid, string>());
_context.PermissionTemplateProjection.Update(template);
await _context.SaveChangesAsync();
var returnTemplate = new PermissionTemplateDTO
{
Id = template.Id,
Name = template.Name,
TemplatePermissions = command.Input.TemplatePermissions,
};
return(returnTemplate);
}
public async Task ListenForEvents(IEvent @event)
{
PermissionDetailProjection perm = new PermissionDetailProjection();
switch (@event)
{
case PermissionCreatedEvent pc:
perm.PermissionId = pc.Id;
perm.Name = pc.Name;
perm.Description = pc.Description;
perm.IsActive = pc.IsActive;
perm.DateCreated = pc.TimeStamp;
perm.Image = pc.Image;
await _context.PermissionDetailProjection.AddAsync(perm);
break;
case PermissionInfoUpdatedEvent pu:
perm = await _context.PermissionDetailProjection.SingleAsync(a => a.PermissionId == pu.Id);
_context.Attach(perm);
perm.Name = pu.Name;
perm.Description = pu.Description;
perm.Image = pu.Image;
_context.Entry(perm).Property(a => a.Name).IsModified = true;
_context.Entry(perm).Property(a => a.Description).IsModified = true;
_context.Entry(perm).Property(a => a.Image).IsModified = true;
_context.PermissionDetailProjection.Update(perm);
break;
case PermissionDisabledEvent pd:
perm = await _context.PermissionDetailProjection.SingleAsync(a => a.PermissionId == pd.Id);
_context.Attach(perm);
perm.IsActive = pd.IsActive;
_context.Entry(perm).Property(a => a.IsActive).IsModified = true;
_context.PermissionDetailProjection.Update(perm);
break;
case PermissionEnabledEvent pe:
perm = await _context.PermissionDetailProjection.SingleAsync(a => a.PermissionId == pe.Id);
_context.Attach(perm);
perm.IsActive = pe.IsActive;
_context.Entry(perm).Property(a => a.IsActive).IsModified = true;
_context.PermissionDetailProjection.Update(perm);
break;
}
await _context.SaveChangesAsync();
}
public async Task <string> Handle(DeletePermissionTemplateCommand command)
{
PermissionTemplateProjection template = await _context.PermissionTemplateProjection.SingleOrDefaultAsync(a => a.Id == command.Input.Id);
if (template != null)
{
_context.PermissionTemplateProjection.Remove(template);
await _context.SaveChangesAsync();
return($"Template \"{template.Name}\" was successfully Removed.");
}
return($"Template was not successfully Removed.");
}
public async Task ListenForEvents(IEvent @event)
{
//listen for permission named changed,
//permission disabled also needs to remove that permission from the template
switch (@event)
{
case PermissionInfoUpdatedEvent pu:
var p = await _context.PermissionTemplateProjection.Where(a =>
JsonConvert.DeserializeObject <Dictionary <Guid, string> >(a.TemplatePermissions).ContainsKey(pu.Id)).ToListAsync();
if (p.Any())
{
foreach (var entry in p)
{
var permissions =
JsonConvert.DeserializeObject <Dictionary <Guid, string> >(entry.TemplatePermissions);
permissions[pu.Id] = pu.Name;
entry.TemplatePermissions = JsonConvert.SerializeObject(permissions);
_context.PermissionTemplateProjection.Update(entry);
}
}
break;
case PermissionDisabledEvent pd:
var templates = await _context.PermissionTemplateProjection.Where(a =>
JsonConvert.DeserializeObject <Dictionary <Guid, string> >(a.TemplatePermissions).ContainsKey(pd.Id)).ToListAsync();
if (templates.Any())
{
foreach (var entry in templates)
{
var permissions =
JsonConvert.DeserializeObject <Dictionary <Guid, string> >(entry.TemplatePermissions);
permissions.Remove(pd.Id);
entry.TemplatePermissions = JsonConvert.SerializeObject(permissions);
_context.PermissionTemplateProjection.Update(entry);
}
}
break;
}
await _context.SaveChangesAsync();
}
public async Task Save(IEnumerable <IEvent> events, CancellationToken cancellationToken = default(CancellationToken))
{
foreach (IEvent e in events)
{
var serializedEvent = BuildEventRowFromEvent(e);
await _context.Events.AddAsync(serializedEvent, cancellationToken);
}
//try
//{
await _context.SaveChangesAsync(cancellationToken);
//}
//catch (Exception e)
//{
// Console.WriteLine(e.StackTrace);
//}
}
public async Task <DepartmentProjection> Handle(RemoveDepartmentCommand command)
{
var department = new DepartmentProjection
{
Id = command.id,
};
try
{
_context.DepartmentProjection.Remove(department);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
}
return(department);
}
public async Task <DepartmentProjection> Handle(CreateDepartmentCommand command)
{
var department = new DepartmentProjection
{
Name = command.Input.Name,
};
try
{
_context.DepartmentProjection.Add(department);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
Console.WriteLine(e.InnerException);
}
return(department);
}
public async Task <PositionProjection> Handle(CreatePositionCommand command)
{
var position = new PositionProjection
{
PositionName = command.Input.PositionName,
DepartmentName = command.Input.DepartmentName,
};
try
{
_context.PositionProjection.Add(position);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
Console.WriteLine(e.InnerException);
}
return(position);
}
public async Task <PositionProjection> Handle(RemovePositionCommand command)
{
var position = new PositionProjection
{
Id = command.id,
};
try
{
_context.PositionProjection.Remove(position);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
Console.WriteLine(e.InnerException);
}
return(position);
}
public async Task <DepartmentProjection> Handle(RemoveDepartmentByNameCommand command)
{
var id = _context.DepartmentProjection.Where(a => a.Name == command.name).Select(a => a.Id).ToListAsync();
var department = new DepartmentProjection
{
Id = id.Result.First(),
Name = command.name,
};
try
{
_context.DepartmentProjection.Remove(department);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
}
return(department);
}
public async Task ListenForEvents(IEvent @event)
{
SystemDropdownProjection permission = new SystemDropdownProjection();
switch (@event)
{
case PermissionCreatedEvent pc:
permission.PermissionID = pc.Id;
permission.PermissionName = pc.Name;
_context.SystemDropDownProjection.Add(permission);
break;
case PermissionInfoUpdatedEvent pu:
permission = await _context.SystemDropDownProjection.SingleAsync(p => p.PermissionID == pu.Id);
permission.PermissionID = pu.Id;
permission.PermissionName = pu.Name;
_context.Update(permission);
break;
}
await _context.SaveChangesAsync();
}
public async Task <PermissionTemplateDTO> Handle(CreatePermissionTemplateCommand command)
{
PermissionTemplateProjection template = new PermissionTemplateProjection
{
Id = Guid.NewGuid(),
Name = command.Input.Name,
TemplatePermissions = command.Input.TemplatePermissions.Any() ?
JsonConvert.SerializeObject(command.Input.TemplatePermissions) :
JsonConvert.SerializeObject(new Dictionary <Guid, string>()),
};
await _context.PermissionTemplateProjection.AddAsync(template);
await _context.SaveChangesAsync();
var returnTemplate = new PermissionTemplateDTO
{
Id = template.Id,
Name = template.Name,
TemplatePermissions = command.Input.TemplatePermissions,
};
return(returnTemplate);
}
public async Task ListenForEvents(IEvent @event)
{
var proj = new UserHistoryProjection();
switch (@event)
{
case UserCreatedEvent uce:
proj.UserId = uce.Id;
proj.Version = uce.Version;
proj.EventType = "User Created";
proj.Operator = "System";
proj.Description = JsonConvert.SerializeObject(uce);
proj.TimeStamp = uce.TimeStamp;
_context.UserHistoryProjection.Add(proj);
break;
case UserUpdatedEvent uue:
proj.UserId = uue.Id;
proj.Version = uue.Version;
proj.EventType = "User Information Updated";
proj.Operator = "System";
proj.Description = Descriptify <UserUpdatedEvent>(uue);
proj.TimeStamp = uue.TimeStamp;
_context.UserHistoryProjection.Add(proj);
break;
case UserDisabledEvent ude:
proj.UserId = ude.Id;
proj.Version = ude.Version;
proj.EventType = "User Disabled";
proj.Operator = await _context.UserDetailProjection.Where(a => a.UserId == ude.ByAgg)
.Select(a => a.FirstName + " " + a.LastName).FirstOrDefaultAsync();
proj.Description = "User was Disabled.";
proj.TimeStamp = ude.TimeStamp;
_context.UserHistoryProjection.Add(proj);
break;
case UserEnabledEvent uee:
proj.UserId = uee.Id;
proj.Version = uee.Version;
proj.EventType = "User Enabled";
proj.Operator = await _context.UserDetailProjection.Where(a => a.UserId == uee.ByAgg)
.Select(a => a.FirstName + " " + a.LastName).FirstOrDefaultAsync();
proj.Description = "User was Enabled.";
proj.TimeStamp = uee.TimeStamp;
_context.UserHistoryProjection.Add(proj);
break;
case UserPermissionsRequestedEvent upre:
proj.UserId = upre.Id;
proj.Version = upre.Version;
proj.EventType = "Permissions Requested";
proj.Operator = await _context.UserDetailProjection.Where(a => a.UserId == upre.Requests.First().Value.RequestedBy)
.Select(a => a.FirstName + " " + a.LastName).FirstOrDefaultAsync();
proj.Description = await Descriptify <UserPermissionsRequestedEvent>(upre);
proj.TimeStamp = upre.TimeStamp;
_context.UserHistoryProjection.Add(proj);
break;
case UserPermissionRequestDeniedEvent uprde:
proj.UserId = uprde.Id;
proj.Version = uprde.Version;
proj.EventType = "Permission requests Denied.";
proj.Operator = await _context.UserDetailProjection.Where(a => a.UserId == uprde.PermissionsToDeny.First().Value.RequestedBy)
.Select(a => a.FirstName + " " + a.LastName).FirstOrDefaultAsync();
proj.Description = await Descriptify <UserPermissionRequestDeniedEvent>(uprde);
proj.TimeStamp = uprde.TimeStamp;
_context.UserHistoryProjection.Add(proj);
break;
case UserPermissionGrantedEvent upge:
proj.UserId = upge.Id;
proj.Version = upge.Version;
proj.EventType = "Permissions Granted";
proj.Operator = await _context.UserDetailProjection.Where(a => a.UserId == upge.PermissionsToGrant.First().Value.RequestedBy)
.Select(a => a.FirstName + " " + a.LastName).FirstOrDefaultAsync();
proj.Description = await Descriptify <UserPermissionGrantedEvent>(upge);
proj.TimeStamp = upge.TimeStamp;
_context.UserHistoryProjection.Add(proj);
break;
case UserPermissionRevokedEvent upre:
proj.UserId = upre.Id;
proj.Version = upre.Version;
proj.EventType = "Permissions Revoked";
proj.Operator = await _context.UserDetailProjection.Where(a => a.UserId == upre.PermissionsToRevoke.First().Value.RequestedBy)
.Select(a => a.FirstName + " " + a.LastName).FirstOrDefaultAsync();
proj.Description = await Descriptify <UserPermissionRevokedEvent>(upre);
proj.TimeStamp = upre.TimeStamp;
_context.UserHistoryProjection.Add(proj);
break;
}
await _context.SaveChangesAsync();
}
public async Task ListenForEvents(IEvent @event)
{
UserManagementProjection user = new UserManagementProjection();
switch (@event)
{
case UserCreatedEvent uc:
user.UserId = uc.Id;
user.FirstName = uc.FirstName;
user.LastName = uc.LastName;
user.Email = uc.Email;
user.Position = uc.Position;
user.Department = uc.Department;
user.IsActive = uc.IsActive;
user.IsAdmin = uc.IsAdmin;
_context.UserManagementProjection.Add(user);
break;
case UserUpdatedEvent uu:
user = await _context.UserManagementProjection.SingleAsync(b => b.UserId == uu.Id);
_context.UserManagementProjection.Attach(user);
user.FirstName = uu.FirstName;
user.LastName = uu.LastName;
user.Email = uu.Email;
user.Position = uu.Position;
user.Department = uu.Department;
user.IsAdmin = uu.IsAdmin;
_context.Entry(user).Property(a => a.FirstName).IsModified = true;
_context.Entry(user).Property(a => a.LastName).IsModified = true;
_context.Entry(user).Property(a => a.Email).IsModified = true;
_context.Entry(user).Property(a => a.Position).IsModified = true;
_context.Entry(user).Property(a => a.Department).IsModified = true;
_context.Entry(user).Property(a => a.IsAdmin).IsModified = true;
_context.UserManagementProjection.Update(user);
break;
case UserDisabledEvent ud:
user = await _context.UserManagementProjection.SingleAsync(b => b.UserId == ud.Id);
_context.UserManagementProjection.Attach(user);
user.IsActive = ud.IsActive;
_context.Entry(user).Property(a => a.IsActive).IsModified = true;
_context.UserManagementProjection.Update(user);
break;
case UserEnabledEvent ue:
user = await _context.UserManagementProjection.SingleAsync(b => b.UserId == ue.Id);
_context.UserManagementProjection.Attach(user);
user.IsActive = ue.IsActive;
_context.Entry(user).Property(a => a.IsActive).IsModified = true;
_context.UserManagementProjection.Update(user);
break;
}
await _context.SaveChangesAsync();
}
public async Task ListenForEvents(IEvent @event)
{
DashboardProjection dBProjection = new DashboardProjection();
switch (@event)
{
case PermissionInfoUpdatedEvent pue:
dBProjection = await _context.DashBoardProjection.SingleAsync(a => a.PermissionId == pue.Id);
_context.Attach(dBProjection);
dBProjection.SystemName = pue.Name;
dBProjection.LogoUrl = pue.Image;
_context.Entry(dBProjection).Property(a => a.SystemName).IsModified = true;
_context.Entry(dBProjection).Property(a => a.LogoUrl).IsModified = true;
_context.DashBoardProjection.Update(dBProjection);
break;
case PermissionCreatedEvent pce:
dBProjection.PermissionId = pce.Id;
dBProjection.SystemName = pce.Name;
dBProjection.ActiveUsers = 0;
dBProjection.PendingRequests = 0;
dBProjection.LogoUrl = pce.Image;
_context.DashBoardProjection.Add(dBProjection);
break;
case UserPermissionsRequestedEvent pre:
//increment pending requests
var rowsToBeUpdated = await _context.DashBoardProjection.Where(a => pre.Requests.ContainsKey(a.PermissionId)).ToListAsync();
foreach (var entry in rowsToBeUpdated)
{
entry.PendingRequests++;
_context.Entry(entry).Property(a => a.PendingRequests).IsModified = true;
_context.Update(entry);
}
break;
case UserPermissionRequestDeniedEvent prd:
//decrement pending requests
var rows = await _context.DashBoardProjection.Where(a => prd.PermissionsToDeny.ContainsKey(a.PermissionId)).ToListAsync();
foreach (var entry in rows)
{
if (entry.PendingRequests <= 1)
{
entry.PendingRequests = 0;
}
else
{
entry.PendingRequests--;
}
_context.Entry(entry).Property(a => a.PendingRequests).IsModified = true;
_context.Update(entry);
}
break;
case UserPermissionGrantedEvent pge:
//increment active users, decrement pending requests
var rs = await _context.DashBoardProjection.Where(a => pge.PermissionsToGrant.ContainsKey(a.PermissionId)).ToListAsync();
var user = await _context.UserDetailProjection.Where(a => a.UserId == pge.ForId).SingleOrDefaultAsync();
var permissionList =
JsonConvert.DeserializeObject <Dictionary <Guid, DetailedUserPermissionInfo> >(
user.PermissionList);
foreach (var entry in rs)
{
entry.ActiveUsers++;
_context.Entry(entry).Property(a => a.ActiveUsers).IsModified = true;
//no need to go further because their list did not contain a definition for this permission meaning it was never previously requested.
if (!permissionList.ContainsKey(entry.PermissionId))
{
_context.Update(entry);
break;
}
// checks previous state of that permission
if (string.Equals(permissionList[entry.PermissionId].PermissionStatus, "Requested"))
{
if (entry.PendingRequests <= 1)
{
entry.PendingRequests = 0;
}
else
{
entry.PendingRequests--;
}
}
_context.Entry(entry).Property(a => a.PendingRequests).IsModified = true;
_context.Update(entry);
}
break;
case UserPermissionRevokedEvent upr:
//decrement active users
var r = await _context.DashBoardProjection.Where(a => upr.PermissionsToRevoke.ContainsKey(a.PermissionId)).ToListAsync();
foreach (var entry in r)
{
if (entry.ActiveUsers <= 1)
{
entry.ActiveUsers = 0;
}
else
{
entry.ActiveUsers--;
}
_context.Entry(entry).Property(a => a.ActiveUsers).IsModified = true;
_context.Update(entry);
}
break;
case UserCreatedEvent uc:
if (uc.PermissionList.Any())
{
var rowsToChange = await _context.DashBoardProjection.Where(a => uc.PermissionList.ContainsKey(a.PermissionId)).ToListAsync();
foreach (var row in rowsToChange)
{
row.ActiveUsers++;
}
}
break;
}
await _context.SaveChangesAsync();
}
public async Task ListenForEvents(IEvent @event)
{
switch (@event)
{
case UserCreatedEvent userCreated:
if (userCreated.PermissionList.Any())
{
foreach (var permission in userCreated.PermissionList)
{
var appAct = new ApproverActivityProjection();
if (userCreated.ById == Guid.Empty)
{
appAct = new ApproverActivityProjection
{
ApproverId = userCreated.ById,
ApproverFullName = "ADMIN",
TimeStamp = userCreated.TimeStamp,
PermissionName = "-",
TruncatedEventType = "User Created without Permissions",
};
}
else
{
appAct = new ApproverActivityProjection
{
ApproverId = userCreated.ById,
ApproverFullName = await _context.UserDetailProjection.Where(a => a.UserId == userCreated.ById).Select(a => a.FirstName + " " + a.LastName).SingleOrDefaultAsync(),
TimeStamp = userCreated.TimeStamp,
PermissionName = await _context.PermissionDetailProjection.Where(p => p.PermissionId == permission.Key).Select(n => n.Name).SingleOrDefaultAsync(),
TruncatedEventType = "User Created with Permissions",
};
}
await _context.ApproverActivityProjection.AddAsync(appAct);
}
}
break;
case PermissionInfoUpdatedEvent permissionInfoUpdated:
if (!(permissionInfoUpdated.Id == Guid.Empty))
{
var approverActivity = new ApproverActivityProjection
{
ApproverId = permissionInfoUpdated.UpdatedById,
ApproverFullName = await _context.UserDetailProjection.Where(a => a.UserId == permissionInfoUpdated.UpdatedById).Select(a => a.FirstName + " " + a.LastName).SingleOrDefaultAsync(),
TimeStamp = permissionInfoUpdated.TimeStamp,
PermissionName = await _context.PermissionDetailProjection.Where(p => p.PermissionId == permissionInfoUpdated.Id).Select(n => n.Name).SingleOrDefaultAsync(),
TruncatedEventType = "Updated Permission",
};
await _context.ApproverActivityProjection.AddAsync(approverActivity);
}
break;
case UserPermissionGrantedEvent permissionGranted:
foreach (var permission in permissionGranted.PermissionsToGrant)
{
var PermissionID = permission.Key;
var approverActivity = new ApproverActivityProjection
{
ApproverId = permissionGranted.ById,
ApproverFullName = await _context.UserDetailProjection.Where(a => a.UserId == permissionGranted.ById).Select(a => a.FirstName + " " + a.LastName).SingleOrDefaultAsync(),
ForId = permissionGranted.Id,
TimeStamp = permissionGranted.TimeStamp,
PermissionName = await _context.PermissionDetailProjection.Where(p => p.PermissionId == PermissionID).Select(n => n.Name).SingleOrDefaultAsync(),
TruncatedEventType = "Granted Permission",
Reason = permission.Value.Reason,
};
approverActivity.ForFullName = await _context.UserDetailProjection.Where(udp => udp.UserId == permissionGranted.ForId).Select(r => r.FirstName + " " + r.LastName).SingleOrDefaultAsync();
await _context.ApproverActivityProjection.AddAsync(approverActivity);
}
break;
case UserPermissionRevokedEvent permissionRevoked:
foreach (var permission in permissionRevoked.PermissionsToRevoke)
{
var PermissionID = permission.Key;
var approverActivity = new ApproverActivityProjection
{
ApproverId = permissionRevoked.ById,
ApproverFullName = await _context.UserDetailProjection.Where(a => a.UserId == permissionRevoked.ById).Select(a => a.FirstName + " " + a.LastName).SingleOrDefaultAsync(),
ForId = permissionRevoked.Id,
TimeStamp = permissionRevoked.TimeStamp,
PermissionName = await _context.PermissionDetailProjection.Where(p => p.PermissionId == PermissionID).Select(n => n.Name).SingleOrDefaultAsync(),
TruncatedEventType = "Revoked Permission",
Reason = permission.Value.Reason,
};
approverActivity.ForFullName = await _context.UserDetailProjection.Where(udp => udp.UserId == permissionRevoked.ForId).Select(r => r.FirstName + " " + r.LastName).SingleOrDefaultAsync();
await _context.ApproverActivityProjection.AddAsync(approverActivity);
}
break;
case UserPermissionRequestDeniedEvent permissionDenied:
foreach (var permission in permissionDenied.PermissionsToDeny)
{
var PermissionID = permission.Key;
var approverActivity = new ApproverActivityProjection
{
ApproverId = permissionDenied.ById,
ApproverFullName = await _context.UserDetailProjection.Where(a => a.UserId == permissionDenied.ById).Select(a => a.FirstName + " " + a.LastName).SingleOrDefaultAsync(),
ForId = permissionDenied.Id,
TimeStamp = permissionDenied.TimeStamp,
PermissionName = await _context.PermissionDetailProjection.Where(p => p.PermissionId == PermissionID).Select(n => n.Name).SingleOrDefaultAsync(),
TruncatedEventType = "Denied Permission",
Reason = permission.Value.Reason
};
approverActivity.ForFullName = await _context.UserDetailProjection.Where(udp => udp.UserId == permissionDenied.ForId).Select(r => r.FirstName + " " + r.LastName).SingleOrDefaultAsync();
await _context.ApproverActivityProjection.AddAsync(approverActivity);
}
break;
}
await _context.SaveChangesAsync();
}
public async Task ListenForEvents(IEvent @event)
{
SystemActivityProjection proj = new SystemActivityProjection();
switch (@event)
{
case UserPermissionGrantedEvent pg:
foreach (var permission in pg.PermissionsToGrant)
{
//US-075
var newGrantedRow = new SystemActivityProjection
{
ForId = pg.ForId,
ById = pg.ById,
PermissionId = permission.Key,
EventType = "Permission Granted",
Timestamp = pg.TimeStamp,
PermissionName = await _context.PermissionDetailProjection.Where(a => a.PermissionId == permission.Key).Select(p => p.Name).SingleOrDefaultAsync(),
ForFullName = await _context.UserDetailProjection.Where(a => a.UserId == pg.ForId).Select(p => p.FirstName + " " + p.LastName).SingleOrDefaultAsync(),
ByFullName = await _context.UserDetailProjection.Where(a => a.UserId == pg.ById).Select(p => p.FirstName + " " + p.LastName).SingleOrDefaultAsync()
};
_context.SystemActivityProjection.Add(newGrantedRow);
}
break;
case UserPermissionRevokedEvent pr:
foreach (var permission in pr.PermissionsToRevoke)
{
var newRevokedRow = new SystemActivityProjection
{
ForId = pr.ForId,
ById = pr.ById,
PermissionId = permission.Key,
EventType = "Permission Revoked",
Timestamp = pr.TimeStamp,
PermissionName = await _context.PermissionDetailProjection.Where(a => a.PermissionId == permission.Key).Select(p => p.Name).SingleOrDefaultAsync(),
ForFullName = await _context.UserDetailProjection.Where(a => a.UserId == pr.ForId).Select(p => p.FirstName + " " + p.LastName).SingleOrDefaultAsync()
};
if (pr.ById != Guid.Empty)
{
newRevokedRow.ByFullName = await _context.UserDetailProjection.Where(a => a.UserId == pr.ById).Select(p => p.FirstName + " " + p.LastName).SingleOrDefaultAsync();
}
else
{
newRevokedRow.ByFullName = "System";
}
await _context.SystemActivityProjection.AddAsync(newRevokedRow);
}
break;
case UserUpdatedEvent uu:
var entries = await _context.SystemActivityProjection.Where(a => a.ForId == uu.Id || a.ById == uu.Id).ToListAsync();
if (entries.Any())
{
foreach (var item in entries)
{
_context.SystemActivityProjection.Attach(item);
if (item.ById == uu.Id)
{
item.ByFullName = uu.FirstName + " " + uu.LastName;
_context.Entry(item).Property(a => a.ByFullName).IsModified = true;
}
if (item.ForId == uu.Id)
{
item.ForFullName = uu.FirstName + " " + uu.LastName;
_context.Entry(item).Property(a => a.ForFullName).IsModified = true;
}
_context.SystemActivityProjection.Update(item);
}
}
break;
case UserCreatedEvent uc:
foreach (var permission in uc.PermissionList)
{
//US-075
var newGrantedRow = new SystemActivityProjection
{
ForId = uc.Id,
ById = uc.ById,
PermissionId = permission.Key,
EventType = "Permission Granted",
Timestamp = uc.TimeStamp,
PermissionName = await _context.PermissionDetailProjection.Where(a => a.PermissionId == permission.Key).Select(p => p.Name).SingleOrDefaultAsync(),
ForFullName = await _context.UserDetailProjection.Where(a => a.UserId == uc.Id).Select(p => p.FirstName + " " + p.LastName).SingleOrDefaultAsync(),
ByFullName = await _context.UserDetailProjection.Where(a => a.UserId == uc.ById).Select(p => p.FirstName + " " + p.LastName).SingleOrDefaultAsync()
};
_context.SystemActivityProjection.Add(newGrantedRow);
}
break;
case PermissionInfoUpdatedEvent pi:
var rows = await _context.SystemActivityProjection.Where(a => a.PermissionId == pi.Id).ToListAsync();
if (rows.Any())
{
foreach (var row in rows)
{
row.PermissionName = pi.Name;
_context.Entry(row).Property(a => a.PermissionName).IsModified = true;
_context.SystemActivityProjection.Update(row);
}
}
break;
}
await _context.SaveChangesAsync();
}
public async Task ListenForEvents(IEvent @event)
{
UserDetailProjection user = new UserDetailProjection();
Dictionary <Guid, DetailedUserPermissionInfo> permissionList =
new Dictionary <Guid, DetailedUserPermissionInfo>();
switch (@event)
{
case UserCreatedEvent uc:
user.UserId = uc.Id;
user.FirstName = uc.FirstName;
user.LastName = uc.LastName;
user.Email = uc.Email;
user.Position = uc.Position;
user.Department = uc.Department;
user.IsActive = uc.IsActive;
user.IsAdmin = uc.IsAdmin;
if (uc.PermissionList != null)
{
foreach (var permission in uc.PermissionList)
{
var userDetail = await _context.UserDetailProjection
.Where(a => a.UserId == permission.Value.RequestedBy).SingleAsync();
permissionList.Add(permission.Key,
new DetailedUserPermissionInfo
{
PermissionName =
await _context.PermissionDetailProjection
.Where(a => a.PermissionId == permission.Key).Select(p => p.Name)
.SingleAsync(),
ApproverFirstName = userDetail.FirstName,
ApproverLastName = userDetail.LastName,
PermissionStatus = "Granted",
});
}
}
user.PermissionList = JsonConvert.SerializeObject(permissionList);
user.DateCreated = uc.TimeStamp;
_context.UserDetailProjection.Add(user);
break;
case UserUpdatedEvent uu:
user = await _context.UserDetailProjection.SingleAsync(b => b.UserId == uu.Id);
_context.UserDetailProjection.Attach(user);
user.FirstName = uu.FirstName;
user.LastName = uu.LastName;
user.Email = uu.Email;
user.Position = uu.Position;
user.Department = uu.Department;
user.IsAdmin = uu.IsAdmin;
_context.Entry(user).Property(a => a.FirstName).IsModified = true;
_context.Entry(user).Property(a => a.LastName).IsModified = true;
_context.Entry(user).Property(a => a.Email).IsModified = true;
_context.Entry(user).Property(a => a.Position).IsModified = true;
_context.Entry(user).Property(a => a.Department).IsModified = true;
_context.Entry(user).Property(a => a.IsAdmin).IsModified = true;
_context.UserDetailProjection.Update(user);
break;
case UserDisabledEvent ud:
user = await _context.UserDetailProjection.SingleAsync(b => b.UserId == ud.Id);
_context.UserDetailProjection.Attach(user);
user.IsActive = ud.IsActive;
_context.Entry(user).Property(a => a.IsActive).IsModified = true;
_context.UserDetailProjection.Update(user);
break;
case UserEnabledEvent ue:
user = await _context.UserDetailProjection.SingleAsync(b => b.UserId == ue.Id);
_context.UserDetailProjection.Attach(user);
user.IsActive = ue.IsActive;
_context.Entry(user).Property(a => a.IsActive).IsModified = true;
_context.UserDetailProjection.Update(user);
break;
case UserPermissionsRequestedEvent upr:
user = await _context.UserDetailProjection.SingleAsync(b => b.UserId == upr.Id);
_context.UserDetailProjection.Attach(user);
permissionList =
JsonConvert.DeserializeObject <Dictionary <Guid, DetailedUserPermissionInfo> >(
user.PermissionList);
foreach (var permission in upr.Requests)
{
if (!permissionList.ContainsKey(permission.Key))
{
var userDetail = await _context.UserDetailProjection
.Where(a => a.UserId == permission.Value.RequestedBy).SingleAsync();
permissionList.Add(permission.Key,
new DetailedUserPermissionInfo
{
PermissionName =
await _context.PermissionDetailProjection
.Where(a => a.PermissionId == permission.Key).Select(p => p.Name)
.SingleAsync(),
ApproverFirstName = userDetail.FirstName,
ApproverLastName = userDetail.LastName,
PermissionStatus = "Requested",
TimeStamp = upr.TimeStamp,
});
}
else
{
permissionList[permission.Key].PermissionStatus = "Requested";
permissionList[permission.Key].TimeStamp = upr.TimeStamp;
}
}
user.PermissionList = JsonConvert.SerializeObject(permissionList);
_context.Entry(user).Property(a => a.PermissionList).IsModified = true;
_context.UserDetailProjection.Update(user);
break;
case UserPermissionRequestDeniedEvent pde:
if (pde.PermissionsToDeny.Any())
{
user = await _context.UserDetailProjection.SingleAsync(a => a.UserId == pde.ForId);
_context.UserDetailProjection.Attach(user);
permissionList =
JsonConvert.DeserializeObject <Dictionary <Guid, DetailedUserPermissionInfo> >(
user.PermissionList);
foreach (var permission in pde.PermissionsToDeny)
{
//Cannot Deny a permission that has not been Requested or has already been Granted
if (permissionList.ContainsKey(permission.Key))
{
permissionList[permission.Key].PermissionStatus = "Denied";
permissionList[permission.Key].TimeStamp = pde.TimeStamp;
}
}
user.PermissionList = JsonConvert.SerializeObject(permissionList);
_context.Entry(user).Property(a => a.PermissionList).IsModified = true;
_context.UserDetailProjection.Update(user);
}
break;
case UserPermissionGrantedEvent pg:
if (pg.PermissionsToGrant.Any())
{
user = await _context.UserDetailProjection.SingleAsync(a => a.UserId == pg.Id);
_context.UserDetailProjection.Attach(user);
permissionList =
JsonConvert.DeserializeObject <Dictionary <Guid, DetailedUserPermissionInfo> >(
user.PermissionList);
foreach (var p in pg.PermissionsToGrant)
{
if (permissionList.ContainsKey(p.Key))
{
permissionList[p.Key].PermissionStatus = "Granted";
permissionList[p.Key].TimeStamp = pg.TimeStamp;
}
else
{
var userDetail = await _context.UserDetailProjection
.Where(a => a.UserId == p.Value.RequestedBy).SingleAsync();
permissionList.Add(p.Key,
new DetailedUserPermissionInfo
{
PermissionName =
await _context.PermissionDetailProjection
.Where(a => a.PermissionId == p.Key).Select(b => b.Name)
.SingleAsync(),
ApproverFirstName = userDetail.FirstName,
ApproverLastName = userDetail.LastName,
PermissionStatus = "Granted",
TimeStamp = pg.TimeStamp,
});
}
}
user.PermissionList = JsonConvert.SerializeObject(permissionList);
_context.Entry(user).Property(c => c.PermissionList).IsModified = true;
_context.UserDetailProjection.Update(user);
}
break;
case UserPermissionRevokedEvent pr:
if (pr.PermissionsToRevoke.Any())
{
user = await _context.UserDetailProjection.SingleAsync(a => a.UserId == pr.Id);
_context.UserDetailProjection.Attach(user);
permissionList =
JsonConvert.DeserializeObject <Dictionary <Guid, DetailedUserPermissionInfo> >(
user.PermissionList);
foreach (var permission in pr.PermissionsToRevoke)
{
//Cannot Deny a permission that has not been Granted
if (permissionList.ContainsKey(permission.Key))
{
permissionList[permission.Key].PermissionStatus = "Revoked";
permissionList[permission.Key].TimeStamp = pr.TimeStamp;
}
}
user.PermissionList = JsonConvert.SerializeObject(permissionList);
_context.Entry(user).Property(a => a.PermissionList).IsModified = true;
_context.UserDetailProjection.Update(user);
}
break;
case PermissionInfoUpdatedEvent pInfoUpdatedEvent:
if (pInfoUpdatedEvent.Name.Any())
{
var aAlist = _context.UserDetailProjection.Where(p =>
JsonConvert
.DeserializeObject <Dictionary <Guid, DetailedUserPermissionInfo> >(p.PermissionList)
.ContainsKey(pInfoUpdatedEvent.Id)).ToList();
var iDToCheck = pInfoUpdatedEvent.Id;
var newName = pInfoUpdatedEvent.Name;
foreach (var aActivity in aAlist)
{
//_context.Entry(aActivity).State = EntityState.Modified;
permissionList =
JsonConvert.DeserializeObject <Dictionary <Guid, DetailedUserPermissionInfo> >(
aActivity.PermissionList);
permissionList[iDToCheck].PermissionName = newName;
aActivity.PermissionList = JsonConvert.SerializeObject(permissionList);
_context.UserDetailProjection.Update(aActivity);
}
}
break;
}
await _context.SaveChangesAsync();
}
public async Task ListenForEvents(IEvent @event)
{
switch (@event)
{
case UserPermissionsRequestedEvent upr:
foreach (var r in upr.Requests)
{
var row = new PendingRequestsProjection
{
PermissionId = r.Key,
ForId = r.Value.RequestedFor,
ById = r.Value.RequestedBy,
RequestType = "Requested Permission",
DateOfRequest = r.Value.RequestDate,
Reason = r.Value.Reason,
};
row.ByFirstName = await _context.UserDetailProjection.Where(a => a.UserId == row.ById).Select(p => p.FirstName).SingleOrDefaultAsync();
row.ByLastName = await _context.UserDetailProjection.Where(a => a.UserId == row.ById).Select(p => p.LastName).SingleOrDefaultAsync();
row.ByFullName = row.ByFirstName + " " + row.ByLastName;
row.ForFirstName = await _context.UserDetailProjection.Where(a => a.UserId == row.ForId).Select(p => p.FirstName).SingleOrDefaultAsync();
row.ForLastName = await _context.UserDetailProjection.Where(a => a.UserId == row.ForId).Select(p => p.LastName).SingleOrDefaultAsync();
row.ForFullName = row.ForFirstName + " " + row.ForLastName;
row.PermissionName = await _context.PermissionDetailProjection.Where(a => a.PermissionId == row.PermissionId).Select(p => p.Name).SingleOrDefaultAsync();
//if a request of that type does not already exist for that user and permission add it to the list
if (!await _context.PendingRequestsProjection.AnyAsync(a =>
a.PermissionId == row.PermissionId && a.ForId == row.ForId && a.RequestType == row.RequestType))
{
await _context.PendingRequestsProjection.AddAsync(row);
}
}
break;
case PermissionDisabledEvent pd:
var list = _context.PendingRequestsProjection.Where(a => a.PermissionId == pd.Id);
_context.PendingRequestsProjection.RemoveRange(list);
break;
case UserPermissionRequestDeniedEvent pd:
var reqList = _context.PendingRequestsProjection.Where(a => a.ForId == pd.ForId && pd.PermissionsToDeny.ContainsKey(a.PermissionId));
if (reqList.Any())
{
foreach (var r in reqList)
{
_context.PendingRequestsProjection.Remove(r);
}
}
break;
case UserPermissionGrantedEvent pg:
var requests = _context.PendingRequestsProjection.Where(a => a.ForId == pg.ForId && pg.PermissionsToGrant.ContainsKey(a.PermissionId));
if (requests.Any())
{
foreach (var r in requests)
{
_context.PendingRequestsProjection.Remove(r);
}
}
break;
}
await _context.SaveChangesAsync();
}
