public async Task <VerificationResult> VerifyContent()
{
VerificationResult verificationResult = new VerificationResult();
Credentials credentials = new Credentials();
credentials.SecretAccessKey = secretAccessKeyTextBox.Text;
credentials.AccessKeyId = accessKeyIdTextBox.Text;
AmazonIdentityManagementServiceClient client = new AmazonIdentityManagementServiceClient(credentials.AccessKeyId, credentials.SecretAccessKey, Amazon.RegionEndpoint.EUWest2);
try
{
GetUserResponse response = await client.GetUserAsync();
verificationResult.IsVerified = string.IsNullOrEmpty(response.User?.UserName);
if (verificationResult.IsVerified)
{
NewVerifiedCredentials?.Invoke(this, credentials);
}
else
{
verificationResult.ErrorMessage = "Failed to verify credentials";
}
}
catch
{
verificationResult.IsVerified = false;
verificationResult.ErrorMessage = "Failed to verify credentials";
}
return(verificationResult);
}
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
GetUserResponse response = new GetUserResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.IsStartElement)
{
if (context.TestExpression("GetUserResult", 2))
{
UnmarshallResult(context, response);
continue;
}
if (context.TestExpression("ResponseMetadata", 2))
{
response.ResponseMetadata = ResponseMetadataUnmarshaller.Instance.Unmarshall(context);
}
}
}
return(response);
}
public void TestCreateGetUser()
{
string username = "******" + DateTime.Now.Ticks;
try
{
CreateUserRequest request = new CreateUserRequest()
{
UserName = username, Path = IAMUtil.TEST_PATH
};
CreateUserResponse response = Client.CreateUser(request);
Assert.AreEqual(username, response.User.UserName);
GetUserResponse getResponse = Client.GetUser(new GetUserRequest()
{
UserName = username
});
Assert.AreEqual(username, getResponse.User.UserName);
Assert.AreNotEqual(DateTime.MinValue, getResponse.User.CreateDate);
}
finally
{
Client.DeleteUser(new DeleteUserRequest()
{
UserName = username
});
}
}
public virtual async Task <AuthEventEnum> RefreshUserDetailsAsync()
{
if (CognitoUser == null)
{
return(AuthEventEnum.Alert_NeedToBeSignedIn);
}
try
{
// Get the current user attributes from the server
// and set UserEmail and IsUserEmailVerified
GetUserResponse getUserResponse = await CognitoUser.GetUserDetailsAsync().ConfigureAwait(false);
foreach (AttributeType item in getUserResponse.UserAttributes)
{
if (item.Name.Equals("email"))
{
email = item.Value;
}
if (item.Name.Equals("email_verified"))
{
IsEmailVerified = item.Value.Equals("true");
}
}
return(AuthEventEnum.Alert_RefreshUserDetailsDone);
}
catch (Exception e)
{
Debug.WriteLine($"RefreshUserDetails threw an exception {e}");
return(AuthEventEnum.Alert_Unknown);
}
}
public void CreateUser(GetUserResponse userResponse)
{
var user = Mapper.Map <GetUserResponse, User>(userResponse);
_userRepository.Add(user);
_userRepository.Save();
}
/// <summary>
/// Internals of handling message
/// </summary>
/// <param name="message">The message.</param>
/// <returns>
/// Response model
/// </returns>
public async Task <GetUserResponse> Handle(GetUserRequest message)
{
var restClient = new RestClient(ConfigurationManager.AppSettings["ServiceEndpoints:Users"]);
var userRequest = new RestRequest("users/{id}", Method.GET);
userRequest.AddUrlSegment("id", message.Id.ToString());
var userResponse = await restClient.ExecuteTaskAsync <Messages.User>(userRequest);
if (userResponse.StatusCode == HttpStatusCode.NotFound)
{
return(new GetUserResponse()
{
ErrorModel = new ErrorModel(ErrorType.NotFound)
});
}
var user = Mapper.Map <User>(userResponse.Data);
var response = new GetUserResponse()
{
Data = user
};
return(response);
}
public GetUserResponse Register(CreateUserRequest request)
{
var hashedPassword = HashPassword(request.Password);
var requestWithHash = new CreateUserRequest
{
FirstName = request.FirstName,
LastName = request.LastName,
Username = request.Username,
Password = hashedPassword
};
var user = _mapper.Map <CreateUserRequest, User>(requestWithHash);
_userRepository.Add(user);
_userRepository.Save();
GetUserResponse userResponse = new GetUserResponse
{
FirstName = user.FirstName,
LastName = user.LastName,
Username = user.Username,
Password = null,
CreatedOn = user.CreatedOn,
Notes = null,
Token = null
};
return(userResponse);
}
public static GetUserResponse Unmarshall(UnmarshallerContext context)
{
GetUserResponse getUserResponse = new GetUserResponse();
getUserResponse.HttpResponse = context.HttpResponse;
getUserResponse.ErrorCode = context.IntegerValue("GetUser.ErrorCode");
getUserResponse.Message = context.StringValue("GetUser.Message");
getUserResponse.Success = context.BooleanValue("GetUser.Success");
getUserResponse.RequestId = context.StringValue("GetUser.RequestId");
GetUserResponse.GetUser_UserInfo userInfo = new GetUserResponse.GetUser_UserInfo();
userInfo.UserName = context.StringValue("GetUser.UserInfo.UserName");
userInfo.CreateTime = context.LongValue("GetUser.UserInfo.CreateTime");
userInfo.GroupId = context.StringValue("GetUser.UserInfo.GroupId");
userInfo.GroupName = context.StringValue("GetUser.UserInfo.GroupName");
userInfo.UserId = context.StringValue("GetUser.UserInfo.UserId");
userInfo.UserTel = context.StringValue("GetUser.UserInfo.UserTel");
userInfo.UserEmail = context.StringValue("GetUser.UserInfo.UserEmail");
userInfo.UserMobile = context.StringValue("GetUser.UserInfo.UserMobile");
userInfo.UserAvatarUrl = context.StringValue("GetUser.UserInfo.UserAvatarUrl");
userInfo.DepartId = context.StringValue("GetUser.UserInfo.DepartId");
userInfo.DepartName = context.StringValue("GetUser.UserInfo.DepartName");
userInfo.JobName = context.StringValue("GetUser.UserInfo.JobName");
getUserResponse.UserInfo = userInfo;
return(getUserResponse);
}
public async Task <IActionResult> AuthorizationGrant(string client_id, string scope, string response_type, string redirect_uri, string state, string userid)
{
var httpClient = _httpClientFactory.CreateClient();
//var response = await httpClient.GetAsync("http://localhost:58336/api/User/GetUser?userId=" + userid);
//var user = HttpResponseExtensions.ContentAsType<GetUserResponse>(response);
var user = new GetUserResponse()
{
Id = Guid.Parse(userid), Active = true
};
AuthenticationProperties props = new AuthenticationProperties
{
IsPersistent = true,
ExpiresUtc = DateTimeOffset.UtcNow.Add(TimeSpan.FromDays(30))
};
if (user != null && user.Active)
{
await HttpContext.SignInAsync(user.Id.ToString(), "", props);
var returnUrl = "/connect/authorize/callback?client_id=" + client_id + "&scope=" + scope + "&response_type=" + response_type + "&redirect_uri=" + redirect_uri + "&state=" + state + "&userid=" + userid;
return(Redirect(returnUrl));
}
else
{
return(BadRequest("User couldn't be found."));
}
}
public async Task <IActionResult> Get(CancellationToken cancellationToken = default)
{
var response = new GetUserResponse();
try
{
// get company and email data from jwt
var company = _httpContext.HttpContext.User.Claims.First(c => c.Type == "company")?.Value;
var email = _httpContext.HttpContext.User.Claims.First(c => c.Type == "username")?.Value;
var filter = new GetUserFilter(company, email);
var user = await _userAppService.GetUser(filter, cancellationToken);
response.StatusCode = 200;
response.Data = user;
return(Ok(response));
}
catch (Exception ex)
{
response.StatusCode = 500;
response.Messages.Add(ResponseMessage.Create(ex, ""));
return(StatusCode(500, response));
}
}
/// <summary>
/// Gets the user by user identifier.
/// </summary>
/// <param name="userId">The user identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <GetUserResponse> GetUserByUserId(Guid userId,
CancellationToken cancellationToken)
{
Guard.ThrowIfInvalidGuid(userId, nameof(userId));
IdentityUser user = await this.UserManager.FindByIdAsync(userId.ToString());
if (user == null)
{
throw new NotFoundException($"No user found with user Id {userId}");
}
GetUserResponse response = new GetUserResponse();
response.Email = user.Email;
response.PhoneNumber = user.PhoneNumber;
response.UserId = userId;
response.UserName = user.UserName;
// Get the users roles
IList <String> roles = await this.UserManager.GetRolesAsync(user);
response.Roles = roles.ToList();
// Get the users claims
IList <Claim> claims = await this.UserManager.GetClaimsAsync(user);
response.Claims = new Dictionary <String, String>();
foreach (Claim claim in claims)
{
response.Claims.Add(claim.Type, claim.Value);
}
return(response);
}
//[ExpectedException(typeof(NoSuchEntityException))]
public void TestDeleteUser()
{
string username = "******" + DateTime.Now.Ticks;
Client.CreateUserAsync(new CreateUserRequest()
{
UserName = username, Path = IAMUtil.TEST_PATH
}).Wait();
GetUserResponse response = Client.GetUserAsync(new GetUserRequest()
{
UserName = username
}).Result;
Assert.AreEqual(username, response.User.UserName);
Client.DeleteUserAsync(new DeleteUserRequest()
{
UserName = username
}).Wait();
AssertExtensions.ExpectExceptionAsync(Client.GetUserAsync(new GetUserRequest()
{
UserName = username
})).Wait();
}
/// <summary>
/// Return Affected Row Or Error If Exist
/// </summary>
/// <param name="request">User Information</param>
/// <returns>Affected Row Or Error If Exist</returns>
public static GetUserResponse User(GetUserResponse request)
{
GetUserResponse response = new GetUserResponse();
try
{
tblUser user = new tblUser()
{
id = request.User.id,
user = request.User.user,
password = request.User.password,
createDate = request.User.createDate,
upDateDate = DateTime.Now,
deleteDate = null,
state = "Active"
};
var result = UserData.Update.Users(user);
if (result.Item1.Error)
{
response.Error.InfoError(result.Item1);
}
else
{
response.Message = result.Item2;
}
}
catch (Exception ex)
{
response.Error.InfoError(ex);
}
return(response);
}
private void UsersLoaded(GetUserResponse response)
{
Users = response.Users;
List <UserDTO> sellers = Users.Where(a => a.RoleId < 3).ToList();
List <UserDTO> deliverers = Users.Where(a => a.RoleId == 1 || a.RoleId == 3).ToList();
Dispatcher.Invoke(() =>
{
ObservableCollection <KeyValuePair <long, string> > list1 = new ObservableCollection <KeyValuePair <long, string> >();
foreach (UserDTO u in sellers)
{
list1.Add(new KeyValuePair <long, string>(u.UserId, u.UserName));
}
Seller.ItemsSource = list1;
ObservableCollection <KeyValuePair <long, string> > list2 = new ObservableCollection <KeyValuePair <long, string> >();
foreach (UserDTO u in deliverers)
{
list2.Add(new KeyValuePair <long, string>(u.UserId, u.UserName));
}
DeliveryPerson.ItemsSource = list2;
DeliveryPerson.SelectionChanged += DeliveryPerson_SelectionChanged;
});
}
public GetUserResponse GetUsers()
{
GetUserResponse response = new GetUserResponse();
try
{
var users = helperClass.GetAllUsers();
if (users == null)
{
return(response = new GetUserResponse
{
StatusCode = 201,
Data = users,
});
}
return(response = new GetUserResponse
{
StatusCode = 200,
Data = users,
});
}
catch (Exception e)
{
return(response = new GetUserResponse
{
StatusCode = 201,
Data = null,
});
}
}
public object Post(GetUser request)
{
GetUserResponse response=new GetUserResponse();
response.User= Db.SingleById<UserAuth>(request.Id);
response.Roles = Db.Select<aspnet_Roles>();
return response;
}
public async Task <RequestResult> GetUserDetails(string username, string password)
{
RequestResult result = new RequestResult();
try
{
GetUserResponse response = new GetUserResponse();
if (cognitoUserSession != null && cognitoUserSession.IsValid())
{
GetUserRequest userRequest = new GetUserRequest();
userRequest.AccessToken = cognitoUserSession.AccessToken;
response = await provider.GetUserAsync(userRequest);
result.Data = response;
result.Status = true;
}
else
{
//this.RefreshToken(username);
result.Status = false;
result.Message = "Not valid session";
}
}
catch (Exception ex)
{
result.Status = false;
result.Message = ex.Message;
}
return(result);
}
protected override object Action(object obj)
{
Driver driver = (Driver)obj;
StationController.PingMyStation(driver.session_token);
DateTime startTime = DateTime.Now;
do
{
Thread.Sleep(2000);
GetUserResponse user = StationController.GetUser(driver.session_token, driver.user_id);
if (user.stations.Count > 0 &&
user.stations[0].accessible != null &&
user.stations[0].accessible == "available")
{
return(null);
}
}while (DateTime.Now - startTime < TimeSpan.FromSeconds(10.0));
Thread.CurrentThread.Abort();
return(null);
}
public GetUserResponse Get(GetUserRequest request)
{
var query = repository
.AsQueryable<Models.User>();
if (request.UserId.HasValue)
{
query = query.Where(user => user.Id == request.UserId);
}
else
{
query = query.Where(user => user.UserName == request.UserName);
}
var model = query
.Select(user => new UserModel
{
Id = user.Id,
Version = user.Version,
CreatedBy = user.CreatedByUser,
CreatedOn = user.CreatedOn,
LastModifiedBy = user.ModifiedByUser,
LastModifiedOn = user.ModifiedOn,
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
ImageId = user.Image != null && !user.Image.IsDeleted ? user.Image.Id : (System.Guid?)null,
ImageCaption = user.Image != null && !user.Image.IsDeleted ? user.Image.Caption : null,
ImageThumbnailUrl = user.Image != null && !user.Image.IsDeleted ? fileUrlResolver.EnsureFullPathUrl(user.Image.PublicThumbnailUrl) : null,
ImageUrl = user.Image != null && !user.Image.IsDeleted ? fileUrlResolver.EnsureFullPathUrl(user.Image.PublicUrl) : null
})
.FirstOne();
var response = new GetUserResponse { Data = model };
if (request.Data.IncludeRoles)
{
response.Roles = repository
.AsQueryable<Models.UserRole>(userRole => userRole.User.Id == model.Id && !userRole.Role.IsDeleted)
.OrderBy(role => role.Role.Name)
.Select(role => new RoleModel
{
Id = role.Role.Id,
Version = role.Role.Version,
CreatedBy = role.Role.CreatedByUser,
CreatedOn = role.Role.CreatedOn,
LastModifiedBy = role.Role.ModifiedByUser,
LastModifiedOn = role.Role.ModifiedOn,
Name = role.Role.Name,
Description = role.Role.Description ?? string.Empty,
IsSystematic = role.Role.IsSystematic
})
.ToList();
}
return response;
}
public async Task <ActionResult <GetUserResponse> > GetUser(string meUserId)
{
if (!ModelState.IsValid)
{
return(BadRequest(new GetUserResponse()));
}
try
{
var user = await _userRetrievalByIdService.Handle(new UserRetrievalByIdQuery(meUserId));
if (user == null)
{
return(NotFound(new GetUserResponse()));
}
var gur = new GetUserResponse();
Mapper.Map(user, gur);
return(Ok(gur));
}
catch (ArgumentException)
{
return(NotFound(new GetUserResponse()));
}
catch (NullReferenceException)
{
return(NotFound(new GetUserResponse()));
}
}
/// <summary>
/// This method is responsible for getting a specific user from the helpdesk system
/// </summary>
/// <param name="id">The UserId of the specific user to be retrieved</param>
/// <returns>The response that indicates if the operation was a success,
/// and the details of the retrieved user if it was</returns>
public GetUserResponse GetUser(int id)
{
s_logger.Info("Getting user...");
GetUserResponse response = new GetUserResponse();
try
{
var dataLayer = new UsersDataLayer();
UserDTO user = dataLayer.GetUser(id);
if (user == null)
{
throw new NotFoundException("Unable to find user!");
}
response.User = user;
response.Status = HttpStatusCode.OK;
}
catch (NotFoundException ex)
{
s_logger.Error(ex, "Unable to find user!");
response.Status = HttpStatusCode.NotFound;
response.StatusMessages.Add(new StatusMessage(HttpStatusCode.NotFound, "Unable to find user!"));
}
catch (Exception ex)
{
s_logger.Error(ex, "Unable to get user!");
response.Status = HttpStatusCode.InternalServerError;
response.StatusMessages.Add(new StatusMessage(HttpStatusCode.InternalServerError, "Unable to get user!"));
}
return(response);
}
public void TestDeleteUser()
{
string username = "******" + DateTime.Now.Ticks;
Client.CreateUser(new CreateUserRequest()
{
UserName = username, Path = IAMUtil.TEST_PATH
});
GetUserResponse response = Client.GetUser(new GetUserRequest()
{
UserName = username
});
Assert.AreEqual(username, response.User.UserName);
Client.DeleteUser(new DeleteUserRequest()
{
UserName = username
});
Client.GetUser(new GetUserRequest()
{
UserName = username
});
}
public static GetUserResponse Unmarshall(UnmarshallerContext _ctx)
{
GetUserResponse getUserResponse = new GetUserResponse();
getUserResponse.HttpResponse = _ctx.HttpResponse;
getUserResponse.RequestId = _ctx.StringValue("GetUser.RequestId");
getUserResponse.Success = _ctx.BooleanValue("GetUser.Success");
getUserResponse.Code = _ctx.StringValue("GetUser.Code");
getUserResponse.Message = _ctx.StringValue("GetUser.Message");
getUserResponse.HttpStatusCode = _ctx.IntegerValue("GetUser.HttpStatusCode");
GetUserResponse.GetUser_User user = new GetUserResponse.GetUser_User();
user.UserId = _ctx.StringValue("GetUser.User.UserId");
user.RamId = _ctx.StringValue("GetUser.User.RamId");
user.InstanceId = _ctx.StringValue("GetUser.User.InstanceId");
GetUserResponse.GetUser_User.GetUser_Detail detail = new GetUserResponse.GetUser_User.GetUser_Detail();
detail.LoginName = _ctx.StringValue("GetUser.User.Detail.LoginName");
detail.DisplayName = _ctx.StringValue("GetUser.User.Detail.DisplayName");
detail.Phone = _ctx.StringValue("GetUser.User.Detail.Phone");
detail.Email = _ctx.StringValue("GetUser.User.Detail.Email");
detail.Department = _ctx.StringValue("GetUser.User.Detail.Department");
user.Detail = detail;
List <GetUserResponse.GetUser_User.GetUser_Role> user_roles = new List <GetUserResponse.GetUser_User.GetUser_Role>();
for (int i = 0; i < _ctx.Length("GetUser.User.Roles.Length"); i++)
{
GetUserResponse.GetUser_User.GetUser_Role role = new GetUserResponse.GetUser_User.GetUser_Role();
role.RoleId = _ctx.StringValue("GetUser.User.Roles[" + i + "].RoleId");
role.InstanceId = _ctx.StringValue("GetUser.User.Roles[" + i + "].InstanceId");
role.RoleName = _ctx.StringValue("GetUser.User.Roles[" + i + "].RoleName");
role.RoleDescription = _ctx.StringValue("GetUser.User.Roles[" + i + "].RoleDescription");
user_roles.Add(role);
}
user.Roles = user_roles;
List <GetUserResponse.GetUser_User.GetUser_SkillLevel> user_skillLevels = new List <GetUserResponse.GetUser_User.GetUser_SkillLevel>();
for (int i = 0; i < _ctx.Length("GetUser.User.SkillLevels.Length"); i++)
{
GetUserResponse.GetUser_User.GetUser_SkillLevel skillLevel = new GetUserResponse.GetUser_User.GetUser_SkillLevel();
skillLevel.SkillLevelId = _ctx.StringValue("GetUser.User.SkillLevels[" + i + "].SkillLevelId");
skillLevel.Level = _ctx.IntegerValue("GetUser.User.SkillLevels[" + i + "].Level");
GetUserResponse.GetUser_User.GetUser_SkillLevel.GetUser_Skill skill = new GetUserResponse.GetUser_User.GetUser_SkillLevel.GetUser_Skill();
skill.SkillGroupId = _ctx.StringValue("GetUser.User.SkillLevels[" + i + "].Skill.SkillGroupId");
skill.InstanceId = _ctx.StringValue("GetUser.User.SkillLevels[" + i + "].Skill.InstanceId");
skill.SkillGroupName = _ctx.StringValue("GetUser.User.SkillLevels[" + i + "].Skill.SkillGroupName");
skill.SkillGroupDescription = _ctx.StringValue("GetUser.User.SkillLevels[" + i + "].Skill.SkillGroupDescription");
skillLevel.Skill = skill;
user_skillLevels.Add(skillLevel);
}
user.SkillLevels = user_skillLevels;
getUserResponse.User = user;
return(getUserResponse);
}
public async Task <GetUserResponse> GetUser(GetUserRequest request)
{
var response = new GetUserResponse();
var userRoles = await _cache.UserRoles();
var roles = await _cache.Roles();
var permissions = await _cache.Permissions();
using (var uow = _uowFactory.GetUnitOfWork())
{
var user = await uow.UserRepo.GetUserById(new Infrastructure.Repositories.UserRepo.Models.GetUserByIdRequest()
{
Id = request.UserId
});
uow.Commit();
var usersRoles = userRoles.Where(ur => ur.User_Id == request.UserId).Select(ur => ur.Role_Id);
response.Roles = roles.Where(r => usersRoles.Contains(r.Id)).ToList();
if (user == null)
{
response.Notifications.AddError($"Could not find user with Id {request.UserId}");
return(response);
}
response.User = user;
return(response);
}
}
public async Task <IActionResult> GetUser(int id)
{
var user = await _context.Users
.Include(u => u.UserRoles)
.ThenInclude(ur => ur.Role)
.FirstOrDefaultAsync(u => u.Id == id);
if (user == null)
{
return(Generate(HttpStatusCode.NotFound, "User not found."));
}
var result = new GetUserResponse
{
Id = user.Id,
EmailAddress = user.EmailAddress,
FirstName = user.FirstName,
LastName = user.LastName,
DateOfBirth = user.DateOfBirth.ToUniversalTime(),
IsLockedOut = user.IsLockedOut,
Roles = user.UserRoles
.Select(ur => ur.Role.Name)
.ToList()
};
return(Generate(HttpStatusCode.OK, result));
}
public ActionResult ReceiveTokenAndLogon(string token, string returnUrl)
{
IUserAccount user = _externalAuthenticationService.GetUserDetailsFrom(token);
if (user.IsAuthenticated)
{
_formsAuthentications.SetAuthenticationToken(user.AuthenticationToken);
GetUserRequest getUserRequest = new GetUserRequest();
getUserRequest.UserID = user.UserID;
GetUserResponse getUserResponse = _userService.GetUser(getUserRequest);
if (getUserResponse.UserFound)
{
//return RedirectBasedOn(returnUrl);
return(RedirectToAction("Index", "GrowerProfile"));
}
else
{
UserAccountView accountView = InitializeAccountViewWithIssue(true, "Sorry we could not find your user account. If you don't have an account with us please register.");
accountView.CallBackSettings.ReturnUrl = returnUrl;
return(View("Login", accountView));
}
}
else
{
UserAccountView accountView = InitializeAccountViewWithIssue(true, "Sorry we could not log you in. Please try again.");
accountView.CallBackSettings.ReturnUrl = returnUrl;
return(View("Login", accountView));
}
}
/// <summary>
/// 获取用户 用 框架获取的例子
/// </summary>
/// <returns></returns>
public GetUserListResponse GetUserList(BasePageRequest request)
{
LogHelper.Info("获取用户");
var userList = _userRepository.Where(s => s.Id > 0).OrderByDescending(s => s.CreateTime).Skip((request.PageIndex - 1) * request.PageSize).Take(request.PageSize);
GetUserListResponse result = new GetUserListResponse();
foreach (var item in userList)
{
//result.userListResponse.Add(new GetUserResponse()
//{
// Id = item.Id,
// Name = item.Name,
// Account = item.Account,
// CreateTime = item.CreateTime.ToString("yyyy-MM-dd HH:mm:ss"),
// UpdateTime = item.UpdateTime.ToString("yyyy-MM-dd HH:mm:ss"),
// PassWord = RSACryptionHelper.RSAEncrypt(item.PassWord),
//});
var model = new GetUserResponse()
{
Id = item.Id,
Name = item.Name,
Account = item.Account,
CreateTime = item.CreateTime.ToString("yyyy-MM-dd HH:mm:ss"),
UpdateTime = item.UpdateTime.ToString("yyyy-MM-dd HH:mm:ss"),
//PassWord = RSACryptionHelper.RSADecrypt(item.PassWord),
};
result.userListResponse.Add(model);
}
return(result);
}
public void TestGetUser()
{
string url = "https://reqres.in/api/users/1";
HttpWebRequest webrequest = (HttpWebRequest)WebRequest.Create(url);
//setting the headers
webrequest.Method = "GET";
webrequest.ContentType = "application/json";
//Response
HttpWebResponse webresponse = (HttpWebResponse)webrequest.GetResponse();
Encoding enc = Encoding.GetEncoding("utf-8");
StreamReader responseStream = new StreamReader(webresponse.GetResponseStream(), enc);
//Send Request and receive Response in a string
string result = responseStream.ReadToEnd();
webresponse.Close();
//Deserialize response
GetUserResponse getUserResponse = JsonConvert.DeserializeObject <GetUserResponse>(result);
Assert.AreEqual(200, (int)webresponse.StatusCode);
Assert.IsNotNull(getUserResponse.data.id);
Assert.AreEqual("George", getUserResponse.data.first_name, message: "First Name mismatch");
Assert.AreEqual("Bluth", getUserResponse.data.last_name, message: "Last Name mismatch");
Assert.AreEqual("https://s3.amazonaws.com/uifaces/faces/twitter/calebogden/128.jpg", getUserResponse.data.avatar, message: "avatar mismatch");
}
public void GetNotFoundTest()
{
var errorMessage = "user";
var expectedResponse = new GetUserResponse {
Exception = new ResourceNotFoundException(errorMessage)
};
var mockService = new Mock <IUserService>();
mockService.Setup(x => x.GetUser(It.IsAny <GetUserRequest>())).Returns(expectedResponse);
var mockRespoonseBuilder = new Mock <IHttpResponseBuilder>();
var controller = new UserController(mockService.Object, mockRespoonseBuilder.Object)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
mockRespoonseBuilder.Setup(x => x.BuildResponse(It.IsAny <HttpRequestMessage>(), expectedResponse))
.Returns(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(expectedResponse.Exception.Message)
});
var response = controller.Get(Guid.NewGuid());
var content = response.Content.ReadAsStringAsync().Result;
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
Assert.AreEqual(errorMessage, content);
mockService.Verify(x => x.GetUser(It.IsAny <GetUserRequest>()), Times.Once);
}
private static void UnmarshallResult(XmlUnmarshallerContext context, GetUserResponse response)
{
int originalDepth = context.CurrentDepth;
int targetDepth = originalDepth + 1;
if (context.IsStartOfDocument)
{
targetDepth += 2;
}
while (context.ReadAtDepth(originalDepth))
{
if (context.IsStartElement || context.IsAttribute)
{
if (context.TestExpression("User", targetDepth))
{
var unmarshaller = UserUnmarshaller.Instance;
response.User = unmarshaller.Unmarshall(context);
continue;
}
}
}
return;
}
public ServiceResponse <bool> ChangePassword([FromBody] ChangePasswordRequest Request)
{
Request.ClientUserId = CurrentUser.Id;
ServiceResponse <bool> response = new ServiceResponse <bool>();
GetUserResponse userResponse = _userService.ChangePassword(Request);
if (userResponse == null || !userResponse.IsSucceed)
{
response.IsSuccessful = userResponse.IsSucceed;
response.Message = userResponse.Message;
response.ResultCode = userResponse.ResultCode;
return(response);
}
LoginUserRequest login = new LoginUserRequest
{
Username = userResponse.User.Username,
Password = Request.NewPassword
};
Login(login);
return(response);
}
public void UpdateUser(GetUserResponse userResponse)
{
var user = _mapper.Map <GetUserResponse, User>(userResponse);
_userRepository.Update(user);
_userRepository.Save();
}
private static SaveUserModel MapModel(GetUserResponse response)
{
var model = new SaveUserModel
{
Version = response.Data.Version,
FirstName = response.Data.FirstName,
LastName = response.Data.LastName,
UserName = response.Data.UserName,
Email = response.Data.Email,
ImageId = response.Data.ImageId
};
if (response.Roles != null)
{
model.Roles = response.Roles.Select(r => r.Name).ToList();
}
return model;
}
