public async Task <UserVM> AddUserToWarehouse(UserWarehouse userWarehouse)
{
var positionForNewUserWarehouse = await DB.UserWarehouseDB.CountAsync(x => x.UserId == userWarehouse.UserId);
userWarehouse.WarehousePositionInTable = ++positionForNewUserWarehouse;
await DB.UserWarehouseDB.AddAsync(userWarehouse);
await DB.SaveChangesAsync();
var addedUser = await DB.Users.FirstOrDefaultAsync(x => x.Id == userWarehouse.UserId);
var userRoleName = await userManager.GetRolesAsync(addedUser);
UserVM userWithRole = new UserVM
{
Id = addedUser.Id,
FullName = addedUser.FullName,
Email = addedUser.Email,
RoleName = userRoleName[0],
HasAbilityToLoad = addedUser.HasAbilityToLoad,
ReportsTo = addedUser.ReportsTo
};
return(userWithRole);
}
public async Task <ActionResult> GetUsersThatAllowToUseWarehouse([FromBody] UserWarehouse userWarehouse)
{
var role = User.Claims.FirstOrDefault(x => x.Type == "Role").Value;
var users = await WarehouseService.GetUsersThatAllowToUseWarehouse(userWarehouse, role);
return(Ok(users));
}
public async Task <ActionResult> GetUserWarehouseById(UserWarehouse userWarehouse)
{
// Getting warehouse by id
var specificUserWarehouse = await DB.UserWarehouseDB.FirstOrDefaultAsync(x => x.WarehouseId == userWarehouse.WarehouseId && x.UserId == userWarehouse.UserId);
// Returning warehouse
return(Ok(specificUserWarehouse));
}
public async Task <ActionResult> ToggleSeeAmountInWarehouse([FromBody] UserWarehouse userWarehouse)
{
var role = User.Claims.FirstOrDefault(x => x.Type == "Role").Value;
var neededUserWarehouse = await DB.UserWarehouseDB.FirstOrDefaultAsync(x => x.WarehouseId == userWarehouse.WarehouseId && x.UserId == userWarehouse.UserId);
neededUserWarehouse.DoesUserHaveAbilityToSeeProductAmount = !neededUserWarehouse.DoesUserHaveAbilityToSeeProductAmount;
DB.UserWarehouseDB.Update(neededUserWarehouse);
await DB.SaveChangesAsync();
return(Ok());
}
private void SetCompanySource(UserWarehouse warehouse)
{
if (warehouse != null)
{
FindUserDetailsResult userDetails = (this.DataContext as FindUserDetailsResult);
ClientCb.ItemsSource = from UserCompany c in userDetails.UserCompanies
where c.WarehouseIdentity == warehouse.WarehouseIdentity
select c;
}
}
public async Task <UserVM> RemoveUserToWarehouse(UserWarehouse userWarehouse)
{
var warehousePosition = await DB.UserWarehouseDB
.Where(x => x.WarehouseId == userWarehouse.WarehouseId && x.UserId == userWarehouse.UserId)
.Select(x => x.WarehousePositionInTable)
.FirstOrDefaultAsync();
var userWarehouseList = await DB.UserWarehouseDB
.AsNoTracking()
.OrderBy(x => x.WarehousePositionInTable)
.Where(x => x.UserId == userWarehouse.UserId)
.ToListAsync();
foreach (var warehouse in userWarehouseList)
{
if (warehouse.WarehousePositionInTable > warehousePosition)
{
warehouse.WarehousePositionInTable = warehouse.WarehousePositionInTable - 1;
DB.UserWarehouseDB.Update(warehouse);
}
}
DB.UserWarehouseDB.Remove(userWarehouse);
await DB.SaveChangesAsync();
var removedUser = await DB.Users.FirstOrDefaultAsync(x => x.Id == userWarehouse.UserId);
var userRoleName = await userManager.GetRolesAsync(removedUser);
UserVM userWithRole = new UserVM
{
Id = removedUser.Id,
FullName = removedUser.FullName,
Email = removedUser.Email,
RoleName = userRoleName[0],
HasAbilityToLoad = removedUser.HasAbilityToLoad,
ReportsTo = removedUser.ReportsTo
};
return(userWithRole);
}
public async Task ChangeWarehousePosition(UserWarehouse userWarehouse)
{
var userWarehouseList = await DB.UserWarehouseDB
.AsNoTracking()
.OrderBy(x => x.WarehousePositionInTable)
.Where(x => x.UserId == userWarehouse.UserId)
.ToListAsync();
if (userWarehouse.WarehousePositionInTable > userWarehouseList.Count || userWarehouse.WarehousePositionInTable < 1)
{
throw new Exception();
}
var warehouseOldPosition = await DB.UserWarehouseDB
.Where(x => x.WarehouseId == userWarehouse.WarehouseId && x.UserId == userWarehouse.UserId)
.Select(x => x.WarehousePositionInTable)
.FirstOrDefaultAsync();
var warehouseWhithTahtWeSwappingPlaces = userWarehouseList.FirstOrDefault(x => x.WarehousePositionInTable == userWarehouse.WarehousePositionInTable);
warehouseWhithTahtWeSwappingPlaces.WarehousePositionInTable = warehouseOldPosition;
DB.UserWarehouseDB.Update(warehouseWhithTahtWeSwappingPlaces);
DB.UserWarehouseDB.Update(userWarehouse);
await DB.SaveChangesAsync();
}
/// <summary>
/// Method add or modifies a warehouse
/// </summary>
/// <param name="newWarehouse">Warehouse object that we want to add or modifie</param>
/// <returns>New warehouse with id included or modified object</returns>
public async Task <Warehouse> SaveWarehouse(Warehouse warehouse, string username)
{
// If warehouse does not have id, that means that it's a new entity, and we need an add functionality
if (warehouse.Id == null || warehouse.Id.Equals(Guid.Empty))
{
var adminRoleId = await DB.Roles.FirstOrDefaultAsync(x => x.Name == "Level one");
var adminId = await DB.UserRoles.FirstOrDefaultAsync(x => x.RoleId == adminRoleId.Id);
// Adding new warehouse to DB
await DB.WarehouseDB.AddAsync(warehouse);
var creator = await DB.Users.FirstOrDefaultAsync(x => x.FullName == username);
if (creator.Id == adminId.UserId)
{
UserWarehouse userWarehouse = new UserWarehouse
{
WarehouseId = warehouse.Id,
UserId = creator.Id,
DoesUserHaveAbilityToSeeProductAmount = true,
WarehousePositionInTable = await DB.UserWarehouseDB.CountAsync(x => x.UserId == creator.Id) + 1
};
await DB.UserWarehouseDB.AddAsync(userWarehouse);
}
else
{
UserWarehouse userWarehouse = new UserWarehouse
{
WarehouseId = warehouse.Id,
UserId = creator.Id,
DoesUserHaveAbilityToSeeProductAmount = true,
WarehousePositionInTable = await DB.UserWarehouseDB.CountAsync(x => x.UserId == creator.Id) + 1
};
UserWarehouse userWarehouseForAdmin = new UserWarehouse
{
WarehouseId = warehouse.Id,
UserId = adminId.UserId,
DoesUserHaveAbilityToSeeProductAmount = true,
WarehousePositionInTable = await DB.UserWarehouseDB.CountAsync(x => x.UserId == adminId.UserId) + 1
};
await DB.UserWarehouseDB.AddAsync(userWarehouse);
await DB.UserWarehouseDB.AddAsync(userWarehouseForAdmin);
}
await SimpleLogTableService.AddAdminLog($"Izveidoja noliktavu: {warehouse.Name}", username);
// Saving changes in DB
await DB.SaveChangesAsync();
// Generating QR code for warehouse
warehouse = await AddQrCodeForWarehouse(warehouse);
}
// If warehouse has an id, that means that it's not a new entity, and we need an edit functionality
else
{
// Getting object from DB that has similar id like in our param variable
var warehouseFromDb = await DB.WarehouseDB.FirstOrDefaultAsync(x => x.Id == warehouse.Id);
// Using mapper to edit all fields
Mapper.Map(warehouse, warehouseFromDb);
// Updating DB
DB.WarehouseDB.Update(warehouseFromDb);
// Saving changes in DB
await DB.SaveChangesAsync();
}
// Returning object
return(warehouse);
}
public async Task <List <UserVM> > GetUsersThatAllowToUseWarehouse(UserWarehouse userWarehouse, string role)
{
List <UserVM> usersVM = new List <UserVM>();
#region level one
if (role == "Level one")
{
var usersForLoop = await DB.Users.Where(x => x.Id != userWarehouse.UserId).ToListAsync();
foreach (var user in usersForLoop)
{
if (await DB.UserWarehouseDB.AnyAsync(x => x.UserId == user.Id && x.WarehouseId == userWarehouse.WarehouseId))
{
var userRoleName = await userManager.GetRolesAsync(user);
var abilityToSeeAmount = await DB.UserWarehouseDB.Where(x => x.UserId == user.Id && x.WarehouseId == userWarehouse.WarehouseId).Select(x => x.DoesUserHaveAbilityToSeeProductAmount).ToListAsync();
UserVM userWithRole = new UserVM
{
Id = user.Id,
FullName = user.FullName,
Email = user.Email,
RoleName = userRoleName[0],
HasAbilityToLoad = user.HasAbilityToLoad,
ReportsTo = user.ReportsTo,
DoesUserHaveAbilityToSeeProductAmount = abilityToSeeAmount[0]
};
usersVM.Add(userWithRole);
}
}
}
#endregion level one
if (role == "Level two")
{
var allEmployees = new List <User>();
var levelThreeEmployees = await DB.Users.Where(x => x.ReportsTo == userWarehouse.UserId).ToListAsync();
allEmployees.AddRange(levelThreeEmployees);
var employeesFirstLoop = await DB.Users.Where(x => x.ReportsTo == userWarehouse.UserId).ToListAsync();
foreach (var employee in levelThreeEmployees)
{
if (await DB.Users.AnyAsync(x => x.ReportsTo == employee.Id))
{
allEmployees.AddRange(await DB.Users.Where(x => x.ReportsTo == employee.Id).ToListAsync());
}
}
var listOnlyWithAllowedUsers = new List <User>();
foreach (var user in allEmployees)
{
if (await DB.UserWarehouseDB.AnyAsync(x => x.UserId == user.Id && x.WarehouseId == userWarehouse.WarehouseId))
{
listOnlyWithAllowedUsers.Add(user);
var userRoleName = await userManager.GetRolesAsync(user);
var abilityToSeeAmount = await DB.UserWarehouseDB.Where(x => x.UserId == user.Id && x.WarehouseId == userWarehouse.WarehouseId).Select(x => x.DoesUserHaveAbilityToSeeProductAmount).ToListAsync();
UserVM userWithRole = new UserVM
{
Id = user.Id,
FullName = user.FullName,
Email = user.Email,
RoleName = userRoleName[0],
HasAbilityToLoad = user.HasAbilityToLoad,
ReportsTo = user.ReportsTo,
DoesUserHaveAbilityToSeeProductAmount = abilityToSeeAmount[0]
};
usersVM.Add(userWithRole);
}
}
}
if (role == "Level three")
{
var levelFourEmployees = await DB.Users.Where(x => x.ReportsTo == userWarehouse.UserId).ToListAsync();
var listOnlyWithAllowedUsers = new List <User>();
listOnlyWithAllowedUsers.AddRange(levelFourEmployees);
foreach (var user in levelFourEmployees)
{
if (await DB.UserWarehouseDB.AnyAsync(x => x.UserId == user.Id && x.WarehouseId == userWarehouse.WarehouseId))
{
var userRoleName = await userManager.GetRolesAsync(user);
var abilityToSeeAmount = await DB.UserWarehouseDB.Where(x => x.UserId == user.Id && x.WarehouseId == userWarehouse.WarehouseId).Select(x => x.DoesUserHaveAbilityToSeeProductAmount).ToListAsync();
UserVM userWithRole = new UserVM
{
Id = user.Id,
FullName = user.FullName,
Email = user.Email,
RoleName = userRoleName[0],
HasAbilityToLoad = user.HasAbilityToLoad,
ReportsTo = user.ReportsTo,
DoesUserHaveAbilityToSeeProductAmount = abilityToSeeAmount[0]
};
usersVM.Add(userWithRole);
}
}
}
return(usersVM);
}
public static void Setup(TestContext cont)
{
userWarehouse = SetupAssemblyInitializer.UserWarehouse;
}
public static void AssemblyInit(TestContext context)
{
UserWarehouse = UserWarehouse.GetInstance();
}
public async Task <ActionResult> ChangeWarehousePosition([FromBody] UserWarehouse userWarehouse)
{
await WarehouseService.ChangeWarehousePosition(userWarehouse);
return(Ok());
}
public async Task <ActionResult> GetUserWarehouse([FromBody] UserWarehouse userWarehouse)
{
var neededUserWarehouse = await DB.UserWarehouseDB.FirstOrDefaultAsync(x => x.WarehouseId == userWarehouse.WarehouseId && x.UserId == userWarehouse.UserId);
return(Ok(neededUserWarehouse));
}
public async Task <ActionResult> RemoveUserToWarehouse([FromBody] UserWarehouse userWarehouse)
{
var removedUser = await WarehouseService.RemoveUserToWarehouse(userWarehouse);
return(Ok(removedUser));
}
public async Task <ActionResult> AddUserToWarehouse([FromBody] UserWarehouse userWarehouse)
{
return(Ok(await WarehouseService.AddUserToWarehouse(userWarehouse)));
}
public async Task <ActionResult> GetMyEmployeesForWarehouse(UserWarehouse userWarehouse)
{
var role = User.Claims.FirstOrDefault(x => x.Type == "Role").Value;
var idOfAnUser = User.Claims.FirstOrDefault(x => x.Type == "UserID").Value;
List <UserVM> usersVM = new List <UserVM>();
if (role == "Level one")
{
var usersForLoop = await DB.Users.Where(x => x.Id != userWarehouse.UserId).ToListAsync();
foreach (var user in usersForLoop)
{
if (!await DB.UserWarehouseDB.AnyAsync(x => x.UserId == user.Id && x.WarehouseId == userWarehouse.WarehouseId))
{
var userRoleName = await userManager.GetRolesAsync(user);
UserVM userWithRole = new UserVM
{
Id = user.Id,
FullName = user.FullName,
Email = user.Email,
RoleName = userRoleName[0],
HasAbilityToLoad = user.HasAbilityToLoad,
ReportsTo = user.ReportsTo
};
usersVM.Add(userWithRole);
}
}
}
if (role == "Level two")
{
var allEmployees = new List <User>();
var levelThreeEmployees = await DB.Users.Where(x => x.ReportsTo == userWarehouse.UserId).ToListAsync();
allEmployees.AddRange(levelThreeEmployees);
var employeesFirstLoop = await DB.Users.Where(x => x.ReportsTo == userWarehouse.UserId).ToListAsync();
foreach (var employee in levelThreeEmployees)
{
if (await DB.Users.AnyAsync(x => x.ReportsTo == employee.Id))
{
allEmployees.AddRange(await DB.Users.Where(x => x.ReportsTo == employee.Id).ToListAsync());
}
}
var listOnlyWithAllowedUsers = new List <User>();
foreach (var user in allEmployees)
{
if (!await DB.UserWarehouseDB.AnyAsync(x => x.UserId == user.Id && x.WarehouseId == userWarehouse.WarehouseId))
{
listOnlyWithAllowedUsers.Add(user);
var userRoleName = await userManager.GetRolesAsync(user);
UserVM userWithRole = new UserVM
{
Id = user.Id,
FullName = user.FullName,
Email = user.Email,
RoleName = userRoleName[0],
HasAbilityToLoad = user.HasAbilityToLoad,
ReportsTo = user.ReportsTo
};
usersVM.Add(userWithRole);
}
}
}
if (role == "Level three")
{
var levelFourEmployees = await DB.Users.Where(x => x.ReportsTo == userWarehouse.UserId).ToListAsync();
var listOnlyWithAllowedUsers = new List <User>();
listOnlyWithAllowedUsers.AddRange(levelFourEmployees);
foreach (var user in levelFourEmployees)
{
if (!await DB.UserWarehouseDB.AnyAsync(x => x.UserId == user.Id && x.WarehouseId == userWarehouse.WarehouseId))
{
var userRoleName = await userManager.GetRolesAsync(user);
UserVM userWithRole = new UserVM
{
Id = user.Id,
FullName = user.FullName,
Email = user.Email,
RoleName = userRoleName[0],
HasAbilityToLoad = user.HasAbilityToLoad,
ReportsTo = user.ReportsTo
};
usersVM.Add(userWithRole);
}
}
}
return(Ok(usersVM));
}
public void SelectAndClose(UserWarehouse selectedWarehouse, UserCompany selectedCompany)
{
if ((selectedWarehouse != null) && (selectedCompany != null))
{
try
{
UserSettingsChangedEventArgs args = new UserSettingsChangedEventArgs();
EventTopic userSettingsTopic = WorkItem.EventTopics.Get(Imi.SupplyChain.UX.UXEventTopicNames.UserSettingsChangedTopic);
if (userSettingsTopic != null)
{
userSettingsTopic.Fire(this, args, WorkItem, PublicationScope.Descendants);
if (args.OpenDialogs.Count > 0)
{
if (ShellInteractionService.ShowMessageBox(this.View.Title, string.Format(LocalResources.ChangeUserSettings_CloseAll, string.Join("\n", args.OpenDialogs)), null, MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No)
{
Close(false);
return;
}
}
}
ShellInteractionService.ShowProgress();
// Get the application
IShellModule module = WorkItem.Items.FindByType <IShellModule>().First();
LogonParameters logonParameters = new LogonParameters();
logonParameters.UserIdentity = UserSessionService.UserId;
logonParameters.CompanyIdentity = selectedCompany.CompanyIdentity;
logonParameters.WarehouseIdentity = selectedCompany.WarehouseIdentity;
logonParameters.TerminalIdentity = UserSessionService.TerminalId;
logonParameters.ApplicationIdentity = module.Id;
LogonRequest logonRequest = new LogonRequest();
logonRequest.LogonParameters = logonParameters;
LogonResponse response = Service.Logon(logonRequest);
// Set the selected Warehouse and ClientId on statusrow in container
ShellInteractionService.ContextInfo = string.Format(LocalResources.STATUSBAR_WH_CLIENT,
selectedWarehouse.WarehouseIdentity,
selectedWarehouse.WarehouseName,
selectedCompany.CompanyIdentity,
selectedCompany.CompanyName);
Close(true);
}
catch (Exception ex)
{
ShellInteractionService.HideProgress();
ShellInteractionService.ShowMessageBox(StringResources.ActionException_Text, ex.Message, ex.ToString(), MessageBoxButton.Ok, MessageBoxImage.Error);
}
finally
{
ShellInteractionService.HideProgress();
}
}
}
public void SelectAndClose(UserWarehouse selectedWarehouse)
{
if (selectedWarehouse != null)
{
try
{
UserSettingsChangedEventArgs args = new UserSettingsChangedEventArgs();
EventTopic userSettingsTopic = WorkItem.EventTopics.Get(Imi.SupplyChain.UX.UXEventTopicNames.UserSettingsChangedTopic);
if (userSettingsTopic != null)
{
userSettingsTopic.Fire(this, args, WorkItem, PublicationScope.Descendants);
if (args.OpenDialogs.Count > 0)
{
if (ShellInteractionService.ShowMessageBox(this.View.Title, string.Format(LocalResources.ChangeUserSettings_CloseAll, string.Join("\n", args.OpenDialogs)), null, MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No)
{
Close();
return;
}
}
}
ShellInteractionService.ShowProgress();
UserSessionService.WarehouseId = selectedWarehouse.WarehouseIdentity;
ModifyUserDetailsParameters modifyUserDetailsParameters = new ModifyUserDetailsParameters();
modifyUserDetailsParameters.UserIdentity = UserSessionService.UserId;
modifyUserDetailsParameters.LastLogonTime = DateTime.Now;
modifyUserDetailsParameters.RecentWarehouseIdentity = selectedWarehouse.WarehouseIdentity;
ModifyUserDetailsRequest serviceRequest = new ModifyUserDetailsRequest();
serviceRequest.ModifyUserDetailsParameters = modifyUserDetailsParameters;
Service.ModifyUserDetails(serviceRequest);
if (userSettingsTopic != null)
{
UserSettingsChangedEventArgs userSettingsChangedEventArgs = new UserSettingsChangedEventArgs(true);
userSettingsTopic.Fire(this, userSettingsChangedEventArgs, WorkItem, PublicationScope.Descendants);
}
// Set the selected Warehouse and ClientId on statusrow in container
ShellInteractionService.ContextInfo = string.Format(LocalResources.STATUSBAR_WH,
selectedWarehouse.WarehouseIdentity,
selectedWarehouse.WarehouseName);
Close();
}
catch (Exception ex)
{
ShellInteractionService.HideProgress();
ShellInteractionService.ShowMessageBox(StringResources.ActionException_Text, ex.Message, ex.ToString(), MessageBoxButton.Ok, MessageBoxImage.Error);
}
finally
{
ShellInteractionService.HideProgress();
}
}
}
