public IActionResult CreateUser([FromBody] UserUpsertDto userDto)
{
if (userDto == null)
{
return(BadRequest(ModelState));
}
if (userRepository.UserExists(userDto.UserName))
{
ModelState.AddModelError("", "Korisnicko ime vec postoji");
return(StatusCode(404, ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var cityObj = mapper.Map <User>(userDto);
if (!userRepository.CreateUser(cityObj))
{
ModelState.AddModelError("", $"Nesto je pogresno u spremanju {cityObj.UserName}");
return(StatusCode(500, ModelState));
}
return(CreatedAtRoute("GetUser", new { id = cityObj.UserId }, cityObj));
}
public async Task <UserDto> UpdateAsync(UserUpsertDto user)
{
var userToUpdate = mapper.Map <DomainModels.User>(user);
var updatedUser = await userRepository.UpdateAsync(userToUpdate);
return(mapper.Map <UserDto>(updatedUser));
}
public static UserDto CreateNewUser(NebulaDbContext dbContext, UserUpsertDto userToCreate, string loginName, Guid userGuid)
{
if (!userToCreate.RoleID.HasValue)
{
return(null);
}
var user = new User
{
UserGuid = userGuid,
LoginName = loginName,
Email = userToCreate.Email,
FirstName = userToCreate.FirstName,
LastName = userToCreate.LastName,
IsActive = true,
RoleID = userToCreate.RoleID.Value,
CreateDate = DateTime.UtcNow,
};
dbContext.User.Add(user);
dbContext.SaveChanges();
dbContext.Entry(user).Reload();
return(GetByUserID(dbContext, user.UserID));
}
public async Task <UserDto> CreateUserAsync(UserUpsertDto userDto)
{
var userToCreate = mapper.Map <DomainModels.User>(userDto);
var createdUser = await userRepository.CreateAsync(userToCreate);
return(mapper.Map <UserDto>(createdUser));
}
public static UserDto UpdateUserEntity(RioDbContext dbContext, int userID, UserUpsertDto userEditDto)
{
if (!userEditDto.RoleID.HasValue)
{
return(null);
}
var user = dbContext.User
.Include(x => x.Role)
.Single(x => x.UserID == userID);
if (user.RoleID != (int)RoleEnum.Admin && userEditDto.RoleID == (int)RoleEnum.Admin)
{
dbContext.AccountUser.RemoveRange(dbContext.AccountUser.Where(x => x.UserID == user.UserID));
}
user.RoleID = userEditDto.RoleID.Value;
user.ReceiveSupportEmails = userEditDto.RoleID.Value == 1 && userEditDto.ReceiveSupportEmails;
user.UpdateDate = DateTime.UtcNow;
dbContext.SaveChanges();
dbContext.Entry(user).Reload();
return(GetByUserID(dbContext, userID));
}
public ActionResult <UserDto> UpdateUser([FromRoute] int userID, [FromBody] UserUpsertDto userUpsertDto)
{
var userDto = EFModels.Entities.User.GetByUserID(_dbContext, userID);
if (ThrowNotFound(userDto, "User", userID, out var actionResult))
{
return(actionResult);
}
var validationMessages =
Nebula.EFModels.Entities.User.ValidateUpdate(_dbContext, userUpsertDto, userDto.UserID);
validationMessages.ForEach(vm => { ModelState.AddModelError(vm.Type, vm.Message); });
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var role = Role.GetByRoleID(_dbContext, userUpsertDto.RoleID.GetValueOrDefault());
if (role == null)
{
return(BadRequest($"Could not find a System Role with the ID {userUpsertDto.RoleID}"));
}
var updatedUserDto = Nebula.EFModels.Entities.User.UpdateUserEntity(_dbContext, userID, userUpsertDto);
return(Ok(updatedUserDto));
}
private UserDto GetAndUpdateUserFromEmailOrReturnNewUser(KeystoneService.KeystoneApiResponse <KeystoneService.KeystoneNewUserModel> response, string email, int roleID)
{
var keystoneUser = response.Payload.Claims;
var existingUser = EFModels.Entities.User.GetByEmail(_dbContext, email);
if (existingUser != null)
{
existingUser = EFModels.Entities.User.UpdateUserGuid(_dbContext, existingUser.UserID, keystoneUser.UserGuid);
return(existingUser);
}
var newUser = new UserUpsertDto
{
FirstName = keystoneUser.FirstName,
LastName = keystoneUser.LastName,
OrganizationName = keystoneUser.OrganizationName,
Email = keystoneUser.Email,
PhoneNumber = keystoneUser.PrimaryPhone,
RoleID = roleID
};
var user = EFModels.Entities.User.CreateNewUser(_dbContext, newUser, keystoneUser.LoginName,
keystoneUser.UserGuid);
return(user);
}
public async Task <IActionResult> UpsertUserAsync(UserUpsertDto dto)
{
var claimsIdentity = this.User.Identity as ClaimsIdentity;
var userId = claimsIdentity.Claims.ToList().FirstOrDefault(x => x.Type == "id").Value;
var companyId = claimsIdentity.Claims.ToList().FirstOrDefault(x => x.Type == "companyId").Value;
var command = new UpsertUserCommand
{
CompanyId = Convert.ToInt32(companyId),
Dto = dto
};
return(await _mediator.Send(command));
}
public static List <ErrorMessage> ValidateUpdate(RioDbContext dbContext, UserUpsertDto userEditDto, int userID)
{
var result = new List <ErrorMessage>();
if (!userEditDto.RoleID.HasValue)
{
result.Add(new ErrorMessage()
{
Type = "Role ID", Message = "Role ID is required."
});
}
return(result);
}
public IActionResult UpdateUser(int id, [FromBody] UserUpsertDto userDto)
{
if (userDto == null || userDto.UserId != id)
{
return(BadRequest(ModelState));
}
var cityObj = mapper.Map <User>(userDto);
if (!userRepository.UpdateUser(cityObj))
{
ModelState.AddModelError("", $"Nesto je pogresno u spremanju {cityObj.UserName}");
return(StatusCode(500, ModelState));
}
return(NoContent());
}
public ActionResult <UserDto> AddAccountsForCurrentUserUsingAccountVerificationKeys([FromBody] UserEditAcountsDto userEditAccountsDto)
{
var userFromContextDto = UserContext.GetUserFromHttpContext(_dbContext, HttpContext);
if (userFromContextDto == null)
{
return(NotFound($"Could not find Current User"));
}
if (!Account.ValidateAllExist(_dbContext, userEditAccountsDto.AccountIDs))
{
return(NotFound("One or more of the Account IDs was invalid."));
}
var currentAccountIDsForUser = Account.ListByUserID(_dbContext, userFromContextDto.UserID).Select(x => x.AccountID).ToList();
var allAccountIDsForUser = userEditAccountsDto.AccountIDs.Union(currentAccountIDsForUser).ToList();
EFModels.Entities.User.SetAssociatedAccounts(_dbContext, userFromContextDto.UserID, allAccountIDsForUser);
if (userFromContextDto.Role.RoleID == (int)RoleEnum.Unassigned)
{
var userUpsertDto = new UserUpsertDto
{
Email = userFromContextDto.Email,
FirstName = userFromContextDto.FirstName,
LastName = userFromContextDto.LastName,
RoleID = (int)RoleEnum.LandOwner,
PhoneNumber = userFromContextDto.Phone
};
userFromContextDto = EFModels.Entities.User.UpdateUserEntity(_dbContext, userFromContextDto.UserID, userUpsertDto);
}
Account.UpdateAccountVerificationKeyLastUsedDateForAccountIDs(_dbContext, userEditAccountsDto.AccountIDs);
return(Ok(userFromContextDto));
}
public IActionResult InviteUser([FromBody] UserInviteDto inviteDto)
{
if (inviteDto.RoleID.HasValue)
{
var role = Role.GetByRoleID(_dbContext, inviteDto.RoleID.Value);
if (role == null)
{
return(BadRequest($"Could not find a Role with the ID {inviteDto.RoleID}"));
}
}
else
{
return(BadRequest("Role ID is required."));
}
var applicationName = $"{_nebulaConfiguration.PlatformLongName}";
var leadOrganizationLongName = $"{_nebulaConfiguration.LeadOrganizationLongName}";
var inviteModel = new KeystoneService.KeystoneInviteModel
{
FirstName = inviteDto.FirstName,
LastName = inviteDto.LastName,
Email = inviteDto.Email,
Subject = $"Invitation to the {applicationName}",
WelcomeText = $"You are receiving this notification because an administrator of the {applicationName}, an online service of the {leadOrganizationLongName}, has invited you to create an account.",
SiteName = applicationName,
SignatureBlock = $"{leadOrganizationLongName}<br /><a href='mailto:{_nebulaConfiguration.LeadOrganizationEmail}'>{_nebulaConfiguration.LeadOrganizationEmail}</a><a href='{_nebulaConfiguration.LeadOrganizationHomeUrl}'>{_nebulaConfiguration.LeadOrganizationHomeUrl}</a>",
RedirectURL = _nebulaConfiguration.KEYSTONE_REDIRECT_URL
};
var response = _keystoneService.Invite(inviteModel);
if (response.StatusCode != HttpStatusCode.OK || response.Error != null)
{
ModelState.AddModelError("Email", $"There was a problem inviting the user to Keystone: {response.Error.Message}.");
if (response.Error.ModelState != null)
{
foreach (var modelStateKey in response.Error.ModelState.Keys)
{
foreach (var err in response.Error.ModelState[modelStateKey])
{
ModelState.AddModelError(modelStateKey, err);
}
}
}
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var keystoneUser = response.Payload.Claims;
var existingUser = EFModels.Entities.User.GetByEmail(_dbContext, inviteDto.Email);
if (existingUser != null)
{
existingUser = EFModels.Entities.User.UpdateUserGuid(_dbContext, existingUser.UserID, keystoneUser.UserGuid);
return(Ok(existingUser));
}
var newUser = new UserUpsertDto
{
FirstName = keystoneUser.FirstName,
LastName = keystoneUser.LastName,
OrganizationName = keystoneUser.OrganizationName,
Email = keystoneUser.Email,
PhoneNumber = keystoneUser.PrimaryPhone,
RoleID = inviteDto.RoleID.Value
};
var user = EFModels.Entities.User.CreateNewUser(_dbContext, newUser, keystoneUser.LoginName,
keystoneUser.UserGuid);
return(Ok(user));
}
public async Task <IActionResult> Handle(GetUserDataQuery request, CancellationToken cancellationToken)
{
try
{
if (!(await PermissionMonitor.CheckPermissionsAsync(_userRepository, request.RequestUserId, "Panel administracji")))
{
return(new JsonResult(new ApiResponse <object>
{
Data = null,
Code = 403,
ErrorMessage = "Brak uprawnień"
}));
}
var user = await _userRepository.GetUserByIdAsync(request.UserId);
if (user != null)
{
var userData = new UserUpsertDto
{
Id = user.Id,
Address = new AddressDto
{
Id = user.Address.Id,
ApartmentNumber = user.Address.ApartmentNumber,
City = user.Address.City,
HouseNumber = user.Address.HouseNumber,
PostCode = user.Address.PostCode,
Province = user.Address.Province,
Street = user.Address.Street
},
Department = user.CompanyPosition,
Email = user.Email,
FirstName = user.FirstName,
Gender = user.Gender,
LastName = user.LastName,
Login = user.UserName,
Password = "",
Permissions = new List <PermissionDto>(),
PhoneNumber = user.PhoneNumber
};
var allPerm = await _userRepository.GetAppClaims();
var userPerms = await _userRepository.GetUserClaims(user.Id);
foreach (var claim in allPerm)
{
userData.Permissions.Add(new PermissionDto
{
Name = claim,
Selected = userPerms.Contains(claim)
});
}
return(new JsonResult(new ApiResponse <UserUpsertDto>
{
Code = 200,
Data = userData,
ErrorMessage = ""
}));
}
else
{
var userData = new UserUpsertDto
{
Id = "",
Address = new AddressDto
{
Id = 0,
ApartmentNumber = "",
City = "",
HouseNumber = "",
PostCode = "",
Province = "",
Street = ""
},
Department = "",
Email = "",
FirstName = "",
Gender = false,
LastName = "",
Login = "",
Password = "",
Permissions = new List <PermissionDto>(),
PhoneNumber = ""
};
var allPerm = await _userRepository.GetAppClaims();
foreach (var claim in allPerm)
{
userData.Permissions.Add(new PermissionDto
{
Name = claim,
Selected = false
});
}
return(new JsonResult(new ApiResponse <UserUpsertDto>
{
Code = 200,
Data = userData,
ErrorMessage = ""
}));
}
}
catch
{
return(new JsonResult(new ApiResponse <object>
{
Code = 500,
Data = null,
ErrorMessage = "Nastąpił problem z serwerem, skontaktuj się z działem IT."
}));
}
}
public static UserDto UpdateUserEntity(NebulaDbContext dbContext, int userID, UserUpsertDto userEditDto)
{
if (!userEditDto.RoleID.HasValue)
{
return(null);
}
var user = dbContext.User
.Include(x => x.Role)
.Single(x => x.UserID == userID);
user.RoleID = userEditDto.RoleID.Value;
user.ReceiveSupportEmails = userEditDto.RoleID.Value == 1 && userEditDto.ReceiveSupportEmails;
user.UpdateDate = DateTime.UtcNow;
dbContext.SaveChanges();
dbContext.Entry(user).Reload();
return(GetByUserID(dbContext, userID));
}
public async Task <ActionResult <UserDto> > CreateAsync([FromBody] UserUpsertDto user)
{
var createdUser = await userService.CreateUserAsync(user);
return(Created("", createdUser));
}
