public async Task <UserProfileResponseModel> UpdateProfile(int id, UserRequestModel userRequestModel)
{
//if (_currentUserService.UserId != userRequestModel.Id)
// throw new HttpException(HttpStatusCode.Unauthorized, "You are not Authorized to Edit");
//var oldUser = await _userRepository.GetByIdAsync(id);
var user = new User()
{
Id = id,
FirstName = userRequestModel.FirstName,
LastName = userRequestModel.LastName,
PhoneNumber = userRequestModel.PhoneNumber,
DateOfBirth = userRequestModel.DateOfBirth,
Email = userRequestModel.Email,
//HashedPassword = CreateHashedPassword(userRequestModel.Password, oldUser.Salt),
//Salt = oldUser.Salt,
};
var profile = await _userRepository.UpdateAsync(user);
var profileResponse = new UserProfileResponseModel()
{
FirstName = profile.FirstName,
LastName = profile.LastName,
PhoneNumber = profile.PhoneNumber,
DateOfBirth = profile.DateOfBirth,
Email = profile.Email,
};
return(profileResponse);
}
public async Task <UserProfileResponseModel> Edit(UserProfileRequestModel userProfileRequestModel)
{
var salt = CreateSalt();
var dbUser = await _userRepository.GetUserByEmail(userProfileRequestModel.Email);
var user = new User()
{
Id = userProfileRequestModel.Id,
Email = userProfileRequestModel.Email,
FirstName = userProfileRequestModel.FirstName == null ? dbUser.FirstName : userProfileRequestModel.FirstName,
LastName = userProfileRequestModel.LastName == null ? dbUser.LastName : userProfileRequestModel.LastName,
Salt = userProfileRequestModel.Password == null ? dbUser.Salt : salt,
HashedPassword = userProfileRequestModel.Password == null ? dbUser.HashedPassword :
CreateHashedPassword(userProfileRequestModel.Password, salt),
PhoneNumber = userProfileRequestModel.PhoneNumber == null ? dbUser.PhoneNumber : userProfileRequestModel.PhoneNumber,
};
var updatedUser = await _userRepository.UpdateAsync(user);
var updatedUserResponse = new UserProfileResponseModel
{
Id = updatedUser.Id,
Email = updatedUser.Email,
FirstName = updatedUser.FirstName,
LastName = updatedUser.LastName
};
return(updatedUserResponse);
// return await _userRepository.UpdateAsync(user);
}
public async Task <UserProfileResponseModel> UpdateUser(UserUpdateRequestModel model)
{
var dbUser = await _userRepository.GetExists(u => u.Email == model.Email);
if (dbUser == false)
{
return(null);
}
var existUser = await _userRepository.GetUserByEmail(model.Email);
existUser.FullName = model.FullName;
existUser.Password = model.Password;
var updatedUser = await _userRepository.Update(existUser);
UserProfileResponseModel response = new UserProfileResponseModel
{
Id = updatedUser.Id,
Email = updatedUser.Email,
FullName = updatedUser.FullName,
JoinedOn = updatedUser.JoinedOn,
};
return(response);
}
/// <summary>
/// 取得使用者個人資料
/// </summary>
/// <param name="userId">userId</param>
/// <returns>UserProfileResponseModel</returns>
public async Task <UserProfileResponseModel> GetProfileAsync(string userId)
{
UserProfileResponseModel responseModel = new UserProfileResponseModel();
responseModel = await _lineClient.GetProfileAsync(userId);
return(responseModel);
}
public async Task <UserProfileResponseModel> GetUserProfileAsync()
{
string userName = _httpContextAccessor.HttpContext.User.Identity.Name;
ApplicationUser user = await _userManager.FindByNameAsync(userName);
UserProfileResponseModel responseModel = new UserProfileResponseModel(user);
return(responseModel);
}
public async Task ShouldGetUserProfile()
{
_userRepositoryMock.GetByIdIncludingImage(Arg.Is <Guid>(id => id == _fakeConfirmedInsertedUser.Id)).Returns(_fakeConfirmedInsertedUser);
UserProfileResponseModel response = await _userService.GetAuthenticatedUserProfile(_fakeConfirmedInsertedUser.Id.ToString());
Assert.Equal(_fakeConfirmedInsertedUser.Name, response.Name);
Assert.Equal(_fakeConfirmedInsertedUser.Email, response.Email);
_fileUploadUtilsMock.Received(1).GenerateImageUrl(Arg.Any <string>());
}
/// <summary>
/// [未測試]取得特定群組中特定使用者的個人資料
/// </summary>
/// <param name="groupId">groupId</param>
/// <param name="userId">userId</param>
/// <returns>UserProfileResponseModel</returns>
public async Task <UserProfileResponseModel> GetGroupMemberProfileAsync(string groupId, string userId)
{
UserProfileResponseModel responseModel = new UserProfileResponseModel();
string apiResult = null;
string para = $"/{groupId}/member/{userId}";
apiResult = await Utility.DoLineHttpGetAsync(MessagingApiUrl.GroupUrl, para, accessToken);
responseModel = JsonConvert.DeserializeObject <UserProfileResponseModel>(apiResult);
return(responseModel);
}
public void ShouldConvertUserToUserProfileResponseModel()
{
User user = new User(Guid.NewGuid(), "name", "*****@*****.**", "password");
ProfileImage profileImage = new ProfileImage("filename", "filepath");
user.AddProfileImage(profileImage);
_fileUploadUtilsMock.GenerateImageUrl(Arg.Any <string>()).Returns("imageurl");
UserProfileResponseModel responseModel = _converter.ConvertUserToUserProfileResponseModel(user);
Assert.Equal(user.Name, responseModel.Name);
Assert.Equal(user.Email, responseModel.Email);
Assert.Equal("imageurl", responseModel.Image);
}
public async Task <IActionResult> Profile()
{
// check if user already logged in
if (User.Identity != null && User.Identity.IsAuthenticated)
{
var profileModel = new UserProfileResponseModel
{
Id = _currentUserService.UserId,
Email = _currentUserService.Email,
FullName = _currentUserService.FullName,
};
return(View(profileModel));
}
return(RedirectToAction("Login"));
}
public async Task <UserProfileResponseModel> GetUserProfile(int id)
{
var user = await _userRepository.GetUserProfileAsync(id);
var theUser = new UserProfileResponseModel
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
DateOfBirth = user.DateOfBirth,
Email = user.Email,
PhoneNumber = user.PhoneNumber,
};
return(theUser);
}
public async Task <UserProfileResponseModel> GetUserDetails(int id)
{
var user = await _userRepository.GetById(id);
if (user == null)
{
throw new NotFoundException("User", id);
}
var userDetails = new UserProfileResponseModel
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
DateOfBirth = user.DateOfBirth
};
return(userDetails);
}
public async Task <UserProfileResponseModel> GetProfile(int id)
{
var user = await _userRepository.GetByIdAsync(id);
if (user == null)
{
throw new NotFoundException("user does not exist");
}
var profile = new UserProfileResponseModel()
{
FirstName = user.FirstName,
LastName = user.LastName,
PhoneNumber = user.PhoneNumber,
Email = user.Email,
DateOfBirth = user.DateOfBirth,
};
return(profile);
}
public async Task <UserProfileResponseModel> GetUserById(int userId)
{
var user = await _userRepository.GetById(userId);
if (user == null)
{
return(null);
}
UserProfileResponseModel response = new UserProfileResponseModel
{
Id = user.Id,
Email = user.Email,
FullName = user.FullName,
JoinedOn = user.JoinedOn,
};
return(response);
}
public async Task <UserProfileResponseModel> RegisterUser(RegisterUserRequestModel model)
{
var user = new User
{
FullName = model.FullName,
Email = model.Email,
Password = model.Password,
JoinedOn = DateTime.Now,
};
var addedUser = await _userRepository.Add(user);
var response = new UserProfileResponseModel
{
Id = addedUser.Id,
Email = addedUser.Email,
FullName = addedUser.FullName,
JoinedOn = addedUser.JoinedOn,
};
return(response);
}
public async Task <UserProfileResponseModel> GetUserProfile(int userId)
{
var user = await _userRepository.GetUserProfileAsync(userId);
var response = new UserProfileResponseModel
{
Id = user.Id,
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
DateOfBirth = user.DateOfBirth,
Email = user.Email,
PhoneNumber = user.PhoneNumber,
TwoFactorEnabled = user.TwoFactorEnabled,
LockoutEndDate = user.LockoutEndDate,
LastLoginDateTime = user.LastLoginDateTime,
Roles = user.UserRoles.Select(ur => new AccountRoleResponseModel {
Id = ur.Role.Id, Name = ur.Role.Name
})
};
return(response);
}
public async Task <UserProfileResponseModel> EditUserProfile(UserProfileRequestModel userProfileRequestModel, int id)
{
var dbUser = await _userRepository.GetUserById(id);
if (dbUser == null)
{
throw new Exception("User does not exist");
}
dbUser.FirstName = userProfileRequestModel.FirstName;
dbUser.LastName = userProfileRequestModel.LastName;
dbUser.Email = userProfileRequestModel.Email;
var updatedUser = await _userRepository.Update(dbUser);
var response = new UserProfileResponseModel
{
Id = updatedUser.Id,
Email = updatedUser.Email,
FullName = updatedUser.FirstName + " " + updatedUser.LastName,
};
return(response);
}
public async Task <UserProfileResponseModel> GetUserProfile()
{
UserProfileResponseModel responseModel = await _userService.GetUserProfileAsync();
return(responseModel);
}
public async Task <IActionResult> Webhook()
{
HttpContext httpContext = HttpContext;
LineMessagingClient client = new LineMessagingClient(accessToken);
ReceiveEventModel model = await WebhookRequestMessage.GetWebhookEvent(httpContext, channelSecret);
if (model == null)
{
return(BadRequest());
}
if (model.events == null)
{
return(BadRequest());
}
foreach (EventModel q in model.events)
{
string senderId = "";
switch (q.source.type)
{
case SourceType.user:
senderId = q.source.userId;
break;
case SourceType.room:
senderId = q.source.roomId;
break;
case SourceType.group:
senderId = q.source.groupId;
break;
}
if (q.type == EventType.message)
{
MessageEventTypeUtility messageEventTypeUtility = new MessageEventTypeUtility(accessToken);
#region ReplyMessage
/*ReplyMessageModel replyMessageBody = new ReplyMessageModel()
* {
* replyToken = q.replyToken,
* messages = await messageEventTypeUtility.AutoProcessMessageType(q.message)
* };
*
* await client.ReplyMessageAsync(replyMessageBody);*/
#endregion
#region ReplyMessageWithJson
await client.ReplyMessageWithJsonAsync(q.replyToken, await messageEventTypeUtility.AutoProcessMessageTypeWithJson(q.message));
#endregion
//await client.ReplyMessageWithJsonAsync(q.replyToken, new ApparelFlexMessage().Create2());
#region push message
/*PushMessageModel pushMessageBody = new PushMessageModel()
* {
* to = "someone's UID",
* messages = messageEventTypeUtility.PushMessageType()
* };
* await client.PushMessageAsync(pushMessageBody);*/
#endregion
#region broadcast message
/*BroadcastModel broadcast = new BroadcastModel()
* {
* messages = messageEventTypeUtility.BroadcastMessageType()
* };
* await client.BroadcastMessageAsync(broadcast);*/
#endregion
Console.WriteLine("Sender: " + senderId);
Console.WriteLine("Message: " + q.message.text);
}
else if (q.type == EventType.follow)
{
MessageEventTypeUtility messageEventTypeUtility = new MessageEventTypeUtility(accessToken);
FollowEventTypeUtility followEventTypeProcessor = new FollowEventTypeUtility(accessToken);
UserProfileResponseModel profileModel = await followEventTypeProcessor.GetProfileAsync(q.source.userId);
string text = $"Welcome, {profileModel.displayName}";
ReplyMessageModel replyMessageBody = new ReplyMessageModel()
{
replyToken = q.replyToken,
messages = messageEventTypeUtility.CreateTextMessage(text)
};
await client.ReplyMessageAsync(replyMessageBody);
}
}
return(Ok());
}
