public async Task <CreateUserProfileResponse> SaveProfile(CreateUserProfileRequest user)
{
IsBusy = true;
try
{
var res = await userProfileAPI.CreateUserProfile(user);
if (res != null)
{
if (res.Code == 0)
{
return(res);
}
else
{
return(null);
}
}
return(null);
}
catch (Exception ex)
{
throw;
}
finally
{
IsBusy = false;
}
}
public override async Task <UserProfileResponse> CreateUserProfile(CreateUserProfileRequest request, ServerCallContext context)
{
var createUserProfileCommand = _mapper.Map <CreateUserProfileCommand>(request);
var response = await _mediator.Send(createUserProfileCommand);
return(_mapper.Map <UserProfileResponse>(response));
}
internal CreateUserProfileResponse CreateUserProfile(CreateUserProfileRequest request)
{
var marshaller = new CreateUserProfileRequestMarshaller();
var unmarshaller = CreateUserProfileResponseUnmarshaller.Instance;
return(Invoke <CreateUserProfileRequest, CreateUserProfileResponse>(request, marshaller, unmarshaller));
}
public async Task <CreateUserProfileResponse> CreateUserProfile(CreateUserProfileRequest user)
{
string url = $"/users/create";
var requestBody = await Task.Run(() => JsonConvert.SerializeObject(user));
using (HttpClient httpClient = new HttpClient())
{
CreateUserProfileResponse data = new CreateUserProfileResponse();
try
{
var authHeader = new AuthenticationHeaderValue("Bearer", await SecureStorage.GetAsync("auth_token"));
httpClient.DefaultRequestHeaders.Authorization = authHeader;
httpClient.BaseAddress = new Uri(Constants.BaseUrl);
StringContent content = new StringContent(requestBody, Encoding.UTF8, "application/json");
HttpResponseMessage result = await httpClient.PostAsync(url, content);
string response = await result.Content.ReadAsStringAsync();
data = JsonConvert.DeserializeObject <CreateUserProfileResponse>(response);
if (result.IsSuccessStatusCode && result.StatusCode == HttpStatusCode.OK)
{
return(data);
}
return(null);
}
catch (Exception exp)
{
return(null);
}
}
}
public UserProfileResponse Create(CreateUserProfileRequest request)
{
var createdUser = _userService.Create(CreateUserFromRequest(request), out _);
CreateUserRole(createdUser.Id, Const.Roles.User);
return(GetUserProfile(createdUser.Id));
}
/// <summary>
/// Get user profile response
/// </summary>
/// <param name="result">Result of get user profile.</param>
private void OnGetUserProfile(Result <UserProfile> result)
{
if (result.IsError)
{
if (result.Error.Code != ErrorCode.UserProfileNotFound)
{
Tools.Log(_textInfo, "Failed to get user profile.", result.Error);
}
// IF user doesn't have any profile, we'll create a default empty user profile
// so the user can update it any time
else
{
Tools.Log(_textInfo, "Default user profile created.");
CreateUserProfileRequest userProfileRequest = new CreateUserProfileRequest {
language = ""
};
userProfiles.CreateUserProfile(userProfileRequest, createResult => { });
}
}
else
{
Tools.Log(_textInfo, "User profile obtained.");
AssignUserProfileToUI(result.Value);
}
}
public async Task <IActionResult> CreateUserProfile([FromBody] CreateUserProfileRequest request)
{
var createUserProfileCommand = new CreateUserProfileCommand(request);
var result = await mediator.Send(createUserProfileCommand);
return(StatusCode((int)result.Code, result.Value));
}
async Task <CreateUserProfileRequest> SaveNewProfileDetails()
{
GenderType foodType = (GenderType)GenderSelector.SelectedItem;
CreateUserProfileRequest newProfileRequest = new CreateUserProfileRequest
{
basicInfo = new Models.UserProfile.CreateUserProfile.BasicInfo
{
userId = OperationData.userId,
firstName = FirstName.Text,
lastName = !string.IsNullOrEmpty(LastName.Text) ? LastName.Text : "",
displayName = DisplayName.Text,
gender = foodType.description,
dob = DoB.Date.ToString("yyyy-MM-dd"),
mobileNumber = ContactNumber.Text,
email = !string.IsNullOrEmpty(Email.Text) ? Email.Text : "",
userLocation = selectedCity.description.ToUpper()
},
address = new Models.UserProfile.CreateUserProfile.Address
{
userId = OperationData.userId,
addressLine1 = AddressLine1.Text,
addressLine2 = AddressLine2.Text,
addressLine3 = !string.IsNullOrEmpty(AddressLine3.Text) ? AddressLine3.Text : "",
zipCode = !string.IsNullOrEmpty(PostalCode.Text) ? PostalCode.Text : "",
state = !string.IsNullOrEmpty(State.Text) ? State.Text : "",
//city = City.Text
city = selectedCity.description
}
};
return(newProfileRequest);
}
public IEnumerator CreateUserProfile(string @namespace, string userAccessToken,
CreateUserProfileRequest createRequest, ResultCallback <UserProfile> callback)
{
Report.GetFunctionLog(this.GetType().Name);
Assert.IsNotNull(@namespace, "Can't create user profile! Namespace parameter is null!");
Assert.IsNotNull(userAccessToken, "Can't create user profile! UserAccessToken parameter is null!");
Assert.IsNotNull(createRequest, "Can't create user profile! CreateRequest parameter is null!");
Assert.IsNotNull(
createRequest.language,
"Can't create user profile! CreateRequest.language parameter is null!");
var request = HttpRequestBuilder
.CreatePost(this.baseUrl + "/v1/public/namespaces/{namespace}/users/me/profiles")
.WithPathParam("namespace", @namespace)
.WithBearerAuth(userAccessToken)
.WithContentType(MediaType.ApplicationJson)
.Accepts(MediaType.ApplicationJson)
.WithBody(createRequest.ToUtf8Json())
.GetResult();
IHttpResponse response = null;
yield return(this.httpWorker.SendRequest(request, rsp => response = rsp));
var result = response.TryParseJson <UserProfile>();
callback.Try(result);
}
public IEnumerator <ITask> CreateUserProfile(string @namespace, string userAccessToken,
CreateUserProfileRequest createRequest, ResultCallback <UserProfile> callback)
{
Assert.IsNotNull(@namespace, "Can't create user profile! Namespace parameter is null!");
Assert.IsNotNull(userAccessToken, "Can't create user profile! UserAccessToken parameter is null!");
Assert.IsNotNull(createRequest, "Can't create user profile! CreateRequest parameter is null!");
Assert.IsNotNull(createRequest.language, "Can't create user profile! CreateRequest.language parameter is null!");
var request = HttpRequestBuilder
.CreatePost(this.baseUrl + "/basic/public/namespaces/{namespace}/users/me/profiles")
.WithPathParam("namespace", @namespace)
.WithBearerAuth(userAccessToken)
.WithContentType(MediaType.ApplicationJson)
.Accepts(MediaType.ApplicationJson)
.WithBody(SimpleJson.SimpleJson.SerializeObject(createRequest))
.ToRequest();
HttpWebResponse response = null;
yield return(Task.Await(request, rsp => response = rsp));
var result = response.TryParseJsonBody <UserProfile>();
callback.Try(result);
}
public async Task <OperationResponse <UserProfileDto> > CreateAsync(CreateUserProfileRequest createUserProfile)
{
var user = _identity.User;
var city = user.FindFirst("city").Value;
var country = user.FindFirst("country").Value;
var firstName = user.FindFirst(ClaimTypes.GivenName).Value;
var lastName = user.FindFirst(ClaimTypes.Surname).Value;
var email = user.FindFirst("emails").Value;
var displayName = user.FindFirst("name").Value;
string profilePictureUrl = "unknown";
var userProfile = new UserProfile
{
Country = country,
City = city,
CreatedOn = DateTime.UtcNow,
FirstName = firstName,
LastName = lastName,
Id = Guid.NewGuid().ToString(),
UserId = _identity.UserId,
IsOrganizer = createUserProfile.IsOrganizer,
ProfilePictureUrl = profilePictureUrl,
Email = email
};
await _uow.UserProfiles.CreateAsync(userProfile);
await _uow.SaveChangesAsync();
return(Success("Userprofile created successfully", userProfile.ToUserProfileDto()));
}
public async Task <ActionResult <CreateUserProfileResponse> > CreateUser(CreateUserProfileRequest user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userEntity = Mapper.Map <UserProfileEntity>(user);
var formattedUser = userEntity with
{
UserName = userEntity.UserName.ToLower(),
PassKey = Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(user.PassKey))
};
try
{
var result = await _userProfileService.CreateUserAsync(formattedUser);
return(Ok(Mapper.Map <CreateUserProfileResponse>(result)));
}
catch (UserNameExistsException)
{
return(BadRequest("User Name already exists"));
}
}
/// <summary>
/// Initiates the asynchronous execution of the CreateUserProfile operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateUserProfile operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/codestar-2017-04-19/CreateUserProfile">REST API Reference for CreateUserProfile Operation</seealso>
public Task <CreateUserProfileResponse> CreateUserProfileAsync(CreateUserProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new CreateUserProfileRequestMarshaller();
var unmarshaller = CreateUserProfileResponseUnmarshaller.Instance;
return(InvokeAsync <CreateUserProfileRequest, CreateUserProfileResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
private User CreateUserFromRequest(CreateUserProfileRequest request)
{
var user = new User();
UpdateUserFields(user, request);
UpdateUserPassword(request.Password, user);
return(user);
}
public Domain.UserProfile Create(CreateUserProfileRequest request)
{
var userProfile = new Domain.UserProfile(0, request.DisplayName);
_repository.Add(userProfile);
_unitOfWork.Commit();
return(userProfile);
}
internal virtual CreateUserProfileResponse CreateUserProfile(CreateUserProfileRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateUserProfileRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateUserProfileResponseUnmarshaller.Instance;
return(Invoke <CreateUserProfileResponse>(request, options));
}
/// <summary>
/// Initiates the asynchronous execution of the CreateUserProfile operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateUserProfile operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/codestar-2017-04-19/CreateUserProfile">REST API Reference for CreateUserProfile Operation</seealso>
public virtual Task <CreateUserProfileResponse> CreateUserProfileAsync(CreateUserProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateUserProfileRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateUserProfileResponseUnmarshaller.Instance;
return(InvokeAsync <CreateUserProfileResponse>(request, options, cancellationToken));
}
public async Task <IActionResult> Post([FromForm] CreateUserProfileRequest model)
{
var operationResponse = await _userProfilesService.CreateAsync(model);
if (operationResponse.IsSuccess)
{
return(Ok(operationResponse));
}
return(BadRequest(operationResponse));
}
public Domain.UserProfile Create(CreateUserProfileRequest request)
{
var userId = _repository.GetNextId();
var userProfile = new Domain.UserProfile(userId, request.DisplayName);
_repository.Add(userProfile);
_repository.Commit();
return(userProfile);
}
public async Task <IActionResult> Create(CreateUserProfileRequest request)
{
var existingUserProfile = await _userProfileReader.GetByEmailAddress(request.EmailAddress);
if (existingUserProfile != null)
{
return(BadRequest("Email address already in use"));
}
var userProfileId = await _userProfileWriter.Add(request.EmailAddress, PasswordHasher.GenerateSecurePassword(request.Password), request.GivenName, request.FamilyName, request.ProfilePicturePath);
return(Ok(userProfileId));
}
/// <summary>
/// Create user profile for current logged in user.
/// </summary>
/// <param name="createRequest">User profile details to create user profile.</param>
/// <param name="callback">Returns a Result that contains UserProfile via callback when completed</param>
public void CreateUserProfile(CreateUserProfileRequest createRequest, ResultCallback <UserProfile> callback)
{
Report.GetFunctionLog(this.GetType().Name);
if (!this.session.IsValid())
{
callback.TryError(ErrorCode.IsNotLoggedIn);
return;
}
this.coroutineRunner.Run(
this.api.CreateUserProfile(this.@namespace, this.session.AuthorizationToken, createRequest, callback));
}
/// <summary>
/// Create user profile for current logged in user.
/// </summary>
/// <param name="createRequest">User profile details to create user profile.</param>
/// <param name="callback">Returns a Result that contains UserProfile via callback when completed</param>
public void CreateUserProfile(CreateUserProfileRequest createRequest,
ResultCallback <UserProfile> callback)
{
if (!this.user.IsLoggedIn)
{
callback.TryError(ErrorCode.IsNotLoggedIn);
return;
}
this.taskDispatcher.Start(
Task.Retry(
cb => this.api.CreateUserProfile(this.@namespace, this.user.AccessToken, createRequest,
result => cb(result)),
result => this.coroutineRunner.Run(() => callback((Result <UserProfile>)result)),
null));
}
// [Authorize(Roles = "Admin, Vendor")]
public async Task <IActionResult> CreateUser([FromForm] CreateUserProfileRequest request)
{
if (!string.IsNullOrWhiteSpace(request.CompanyDistrictsString))
{
var companyDistricts = JsonConvert.DeserializeObject <List <CompanyDistricts> >(request.CompanyDistrictsString);
request.CompanyDistricts = companyDistricts;
}
if (!string.IsNullOrWhiteSpace(request.ProfilePermissionString))
{
var permissions = JsonConvert.DeserializeObject <ProfilePermission>(request.ProfilePermissionString);
request.ProfilePermission = new List <ProfilePermission>()
{
permissions
};
}
var result = await userService.CreateUserProfile(request);
return(StatusCode((int)result.Code, result.Value));
}
public async Task CreateUser_ResponseStatus_400(CreateUserProfileRequest request, SerializableError expectedResult)
{
// Arrange
var mockUserProfileService = new Mock <IUserProfileService>();
var userProfileEntity = Mapper.Map <UserProfileEntity>(request);
mockUserProfileService.Setup(x => x.CreateUserAsync(It.IsAny <UserProfileEntity>())).Throws <UserNameExistsException>();
var userController = new UserController(Mapper, mockUserProfileService.Object, null, null);
MockModelState(request, userController);
// Act
var response = await userController.CreateUser(request);
// Assert
var badObjectResult = Assert.IsType <BadRequestObjectResult>(response.Result);
var result = Assert.IsType <SerializableError>(badObjectResult.Value);
Assert.Equal(expectedResult, result);
}
public async Task CreateUser_ResponseStatus_200(CreateUserProfileRequest request, CreateUserProfileResponse expectedResult)
{
// Arrange
var userProfileEntity = Mapper.Map <UserProfileEntity>(request);
var mockUserProfileService = new Mock <IUserProfileService>();
mockUserProfileService.Setup(x => x.CreateUserAsync(It.IsAny <UserProfileEntity>())).Returns(Task.FromResult(userProfileEntity));
var userController = new UserController(Mapper, mockUserProfileService.Object, null, null);
MockModelState(request, userController);
// Act
var response = await userController.CreateUser(request);
// Assert
var okObjectResult = Assert.IsType <OkObjectResult>(response.Result);
var result = Assert.IsType <CreateUserProfileResponse>(okObjectResult.Value);
Assert.Equal(expectedResult.UserName, result.UserName);
}
public CreateUserProfileResponse SaveUserProfile(CreateUserProfileRequest userprofileRequest)
{
var createUserProfileResponse = new CreateUserProfileResponse();
var userprofile = _messageMapper.MapToUserProfile(userprofileRequest.UserProfile);
try
{
_userprofileRepository.SaveUserProfile(userprofile);
var userprofileDto = _messageMapper.MapToUserProfileDto(userprofile);
createUserProfileResponse.UserProfile = userprofileDto;
createUserProfileResponse.Messages.Add("Successfully saved the userprofile");
createUserProfileResponse.StatusCode = HttpStatusCode.Created;
}
catch (Exception e)
{
var error = e.ToString();
createUserProfileResponse.Messages.Add(error);
createUserProfileResponse.StatusCode = HttpStatusCode.InternalServerError;
}
return(createUserProfileResponse);
}
/// <summary>
/// Creates the user.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
public async Task <APIResponse> CreateUserProfile(CreateUserProfileRequest request)
{
try
{
string filename = "";
var folderName = Path.Combine("UserProfiles");
var pathToSave = Path.Combine("D:", "HappyWedding", folderName);
if (request.ProfilePhoto.Length > 0)
{
string format = System.IO.Path.GetExtension(request.ProfilePhoto.FileName);
filename = request.UserId + "_UserProfiles_" + DateTime.Now + format;
string filenme = filename.Replace(":", ".");
var filePath = Path.Combine(pathToSave, filenme);
using var fileStream = new FileStream(filePath, FileMode.Create);
request.ProfilePhoto.CopyTo(fileStream);
request.Photo = filePath;
request.ProfilePhoto = null;
}
var client = httpClientFactory.CreateClient(IdentityServiceOperation.serviceName);
var param = JsonConvert.SerializeObject(request);
HttpContent contentPost = new StringContent(param, Encoding.UTF8, "application/json");
var response = await client.PostAsync(servicesConfig.Identity + IdentityServiceOperation.CreateUser(), contentPost);
var userprofile = JsonConvert.DeserializeObject <UserIdDetails>(await response.Content.ReadAsStringAsync());
return(new APIResponse(userprofile, HttpStatusCode.Created));
}
catch (Exception ex)
{
logger.Error(ex, "Exception in method 'CreateUser()'");
var exMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
return(new APIResponse(exMessage, HttpStatusCode.InternalServerError));
}
}
public int CreateProfile(string userId, CreateUserProfileRequest Model) // post
{
int _id = 0;
DataProvider.ExecuteNonQuery(GetConnection, "dbo.UserProfile_InsertNewUser"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@firstName", Model.FirstName);
paramCollection.AddWithValue("@lastName", Model.LastName);
paramCollection.AddWithValue("@userName", Model.UserName);
paramCollection.AddWithValue("@tagline", Model.Tagline);
paramCollection.AddWithValue("@userID", userId);
SqlParameter p = new SqlParameter("@Id", System.Data.SqlDbType.Int);
p.Direction = System.Data.ParameterDirection.Output;
paramCollection.Add(p);
},
returnParameters : delegate(SqlParameterCollection param)
{
int.TryParse(param["@Id"].Value.ToString(), out _id);
}
);
return(_id);
}
public HttpResponseMessage PostRegistration(RegistrationRequest model)
{
IdentityUser newUserRegistration;
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
// When model is valid, CreateUser will post email and pw to database
try
{
newUserRegistration = UserService.CreateUser(model.Email, model.Password, model.Username);
CreateUserProfileRequest NewUserProfile = new CreateUserProfileRequest();
NewUserProfile.UserName = model.Username;
NewUserProfile.FirstName = model.FirstName;
NewUserProfile.LastName = model.LastName;
_UserProfileService.CreateProfile(newUserRegistration.Id, NewUserProfile);
}
catch (IdentityResultException) // Display error code and message if user was not created
{
var ExceptionError = new ErrorResponse();
return(Request.CreateResponse(HttpStatusCode.BadRequest, ExceptionError));
}
// Insert new user's id into token table and generate new token
//string UserId = newUserRegistration.Id;
//Guid NewToken = _IUserTokenService.Insert(UserId);
// Pass new user's email and token into emailservice for activation link
//try
//{
// string NewUserEmail = newUserRegistration.Email;
// UserEmailService.SendProfileEmail(NewToken, NewUserEmail);
//}
//catch (NotImplementedException)
//{
// var ExceptionError = new ErrorResponse("Failed to send activation email to new user");
// return Request.CreateResponse(HttpStatusCode.BadRequest, ExceptionError);
//}
//SystemEventService.AddSystemEvent(new AddSystemEventModel
//{
// ActorUserId = UserId,
// ActorType = ActorType.User,
// EventType = SystemEventType.UserRegistration
//});
return(Request.CreateResponse(HttpStatusCode.OK, model));
}
/// <summary>
/// The CreateUserProfile
/// </summary>
/// <param name="userToken">The userToken<see cref="UserToken"/></param>
/// <param name="request">The request<see cref="CreateUserProfileRequest"/></param>
/// <returns>The <see cref="Task{ResponseData{CreateUserProfileResponse}}"/></returns>
public async Task <ResponseData <CreateUserProfileResponse> > CreateUserProfile(UserToken userToken, CreateUserProfileRequest request)
{
try
{
var response = new ResponseData <CreateUserProfileResponse>();
if (userToken == null)
{
throw new UnauthorizedAccessException();
}
//var organization = await _ctx.moncli_info.
// Where(p => p.moncli_infoId == request.OrganizationId).
// AsNoTracking().
// FirstOrDefaultAsync();
//if (organization == null)
// throw new ServiceException("Несуществующая организация");
var selfProfile = await _ctx.XUserInfo
.Where(p => p.login == userToken.Id.ToString())
.AsNoTracking()
.FirstOrDefaultAsync();
var currentuser = await _userManager.Users.FirstOrDefaultAsync(p => p.Id == userToken.Id);
if (await _userManager.IsInRoleAsync(currentuser, MyIdentityRole.ROLE_SUPERADMIN) ||
(await _userManager.IsInRoleAsync(currentuser, MyIdentityRole.ROLE_ADMIN)
//&& selfProfile.theClient == request.OrganizationId
))
{
// ok, have access
}
else
{
throw new UnauthorizedAccessException();
}
var role = await _roleManager.FindByNameAsync(request.Role);
if (role == null)
{
throw new ServiceException("Роль не найдена");
}
var user = new ApplicationUser
{
Id = Guid.NewGuid(),
Email = request.Email,
EmailConfirmed = true,
UserName = request.Email,
};
var createUserResult = await _userManager.CreateAsync(user, request.Password);
if (!createUserResult.Succeeded)
{
throw new ServiceException("Не удалось создать пользователя");
}
var addRoleResult = await _userManager.AddToRoleAsync(user, request.Role);
if (!addRoleResult.Succeeded)
{
throw new ServiceException("Не удалось назначить роль");
}
_ctx.Add(new XUserInfo
{
eMail = request.Email,
name = request.FirstName,
family = request.FirstName,
middleName = request.MiddleName,
//theClient = request.OrganizationId,
phone = request.Phone,
//login = user.Id.ToString(),
XUserInfoId = user.Id
});
await _ctx.SaveChangesAsync();
response.code = BaseStatus.Success;
response.data = new CreateUserProfileResponse
{
Status = "ok",
Id = user.Id
};
return(response);
}
catch (Exception ex)
{
_logger.LogError(ex, "could not create user profile");
return(new ResponseData <CreateUserProfileResponse>
{
code = BaseStatus.Exception,
message = "Не удалось создать пользователя",
description = ex.Message
});
}
}
