public static void CopyFromEntity(GetUserDetailsResponse response, Consumer consumer)
{
if (response.user_details == null)
{
response.user_details = new UserDetailsDto();
}
response.user_details.user_id = consumer.ConsID;
//response.user_details.user_activated = consumer.ConsActivated ? 1 : 0;
//response.user_details.user_blocked = consumer.ConsBlocked ? 1 : 0;
response.user_details.user_name = consumer.Name;
response.user_details.user_mobile_num = consumer.PhoneNumber;
//response.user_details.user_created_date = consumer.CreatedDate;
//response.user_details.user_last_login = consumer.LastLogin ?? DateTime.MinValue;
response.user_details.profile_image = consumer.ProfileImage != null ? ImagePathService.consumerImagePath + consumer.ProfileImage : string.Empty;
//if (consumer.ConsumerAddresses.Count() > 0)
//{
// response.user_details.user_addresses = new List<UserAddressesDto>();
// foreach (ConsumerAddress consAddr in consumer.ConsumerAddresses)
// {
// UserAddressesDto usrAddr = new UserAddressesDto();
// CopyFromEntity(usrAddr, consAddr, consumer.Name);
// response.user_details.user_addresses.Add(usrAddr);
// if (consAddr.IsDefault)
// {
// response.user_details.user_latitude = consAddr.Latitude;
// response.user_details.user_longitude = consAddr.Longitude;
// }
// }
//}
response.user_details.user_mobile_num = consumer.PhoneNumber;
}
public GetUserDetailsResponse GetUserDetails(GetUserDetailsRequest request)
{
GetUserDetailsResponse response = new GetUserDetailsResponse();
Consumer consumer = null;
try
{
using (UserDao dao = new UserDao())
{
consumer = GetAuthUser(dao, request.user_id, request.auth_token, true);
if (consumer == null)
{
MakeNouserResponse(response);
return(response);
}
UsersHelper.CopyFromEntity(response, consumer);
response.has_resource = 1;
response.code = 0;
response.message = MessagesSource.GetMessage("user.details");
return(response);
}
}
catch (Exception ex)
{
response.MakeExceptionResponse(ex);
return(response);
}
}
/// <summary>
/// Returns basic information about the logged-in user
/// Endpoint : https://api.surveymonkey.net/v2/user/get_user_details?api_key=your_api_key
/// Example Request
/// curl -H 'Authorization:bearer XXXYYYZZZ' -H 'Content-Type: application/json' https://api.surveymonkey.net/v2/user/get_user_details/?api_key=your_api_key
/// </summary>
public GetUserDetailsResponse GetUserDetails(BasicRequestData requestData)
{
JsonResponse = MakeApiRequest(GET_USER_DETAILS, requestData);
GetUserDetailsResponse surveyList = JsonConvert.DeserializeObject <GetUserDetailsResponse>(JsonResponse);
return(surveyList);
}
public void GetUserDetails()
{
GetUserDetailsRequest request = new GetUserDetailsRequest(connection, testToken, testUser);
GetUserDetailsResponse response = request.Send();
Assert.AreEqual(response.StatusCode, System.Net.HttpStatusCode.OK);
}
/**
* Get user details.
*/
public static async Task <GetUserDetailsResponse> GetUserDetails(AmazonDynamoDBClient dbClient, string loggedInUserId)
{
Debug.Untested();
Debug.AssertValid(dbClient);
Debug.AssertID(loggedInUserId);
User user = await IdentityServiceLogicLayer.FindUserByID(dbClient, loggedInUserId);
Debug.AssertValid(user);
GetUserDetailsResponse retVal = new GetUserDetailsResponse()
{
emailAddress = user.EmailAddress,
givenName = user.GivenName,
familyName = user.FamilyName,
preferredName = user.PreferredName,
fullName = user.FullName,
dateOfBirth = APIHelper.APIDateStringFromDate(user.DateOfBirth),
gender = user.Gender,
address1 = user.Address1,
address2 = user.Address2,
address3 = user.Address3,
address4 = user.Address4,
city = user.City,
region = user.Region,
country = user.Country,
postalCode = user.PostalCode,
phoneNumber = user.PhoneNumber,
phoneNumberVerified = APIHelper.APIDateTimeStringFromDateTime(user.PhoneNumberVerified),
newEmailAddress = user.NewEmailAddress,
allowNonEssentialEmails = user.AllowNonEssentialEmails,
totalTicketsPurchased = user.TotalTicketsPurchased,
ticketsPurchasedInCurrentGame = user.TicketsPurchasedInCurrentGame,
preferredLanguage = user.PreferredLanguage,
preferredCurrency = user.PreferredCurrency,
preferredTimeZone = user.PreferredTimeZone,
maxDailySpendingAmount = user.MaxDailySpendingAmount,
newMaxDailySpendingAmount = user.NewMaxDailySpendingAmount,
newMaxDailySpendingAmountTime = APIHelper.APIDateTimeStringFromDateTime(user.NewMaxDailySpendingAmountTime),
maxTimeLoggedIn = user.MaxTimeLoggedIn,
newMaxTimeLoggedIn = user.NewMaxTimeLoggedIn,
newMaxTimeLoggedInTime = APIHelper.APIDateTimeStringFromDateTime(user.NewMaxTimeLoggedInTime),
excludeUntil = APIHelper.APIDateTimeStringFromDateTime(user.ExcludeUntil),
newExcludeUntil = APIHelper.APIDateTimeStringFromDateTime(user.NewExcludeUntil),
newExcludeUntilTime = APIHelper.APIDateTimeStringFromDateTime(user.NewExcludeUntilTime)
};
return(retVal);
}
public async Task <GetUserDetailsResponse> GetUserInformationAsync(GetUserDetailsRequest userDetails)
{
try
{
var context = new UserDetailsContext();
var userInformation = context.UserDetails.Where(user => user.UserEmail == userDetails.UserEmail).SingleOrDefault();
GetUserDetailsResponse userResponse = new GetUserDetailsResponse();
userResponse.FirstName = userInformation.FirstName;
userResponse.LastName = userInformation.LastName;
userResponse.PhoneNumber = userInformation.PhoneNumber;
userResponse.UserEmail = userInformation.UserEmail;
userResponse.UserType = ((UserAccessType)userInformation.UserTypeId).ToString();
return(userResponse);
}
catch (Exception e)
{
throw;
return(null);
}
}
public ActionResult EditInfo()
{
string connection = ConfigurationManager.AppSettings["InternalAPIURL"];
var ctx = Request.GetOwinContext();
ClaimsPrincipal user = ctx.Authentication.User;
string accessToken = user.Claims.FirstOrDefault(x => x.Type == "AccessToken").Value;
string userID = user.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value;
GetUserDetailsRequest userDetailRequest = new GetUserDetailsRequest(connection, accessToken, new Guid(userID));
GetUserDetailsResponse userDetailResponse = userDetailRequest.Send();
EditInfo model = new EditInfo()
{
Nicknane = userDetailResponse.NICKNAME,
FirstName = userDetailResponse.FIRST_NAME,
LastName = userDetailResponse.LAST_NAME,
};
return(View(model));
}
public ActionResult Index()
{
string connection = ConfigurationManager.AppSettings["InternalAPIURL"];
ClaimsIdentity identity = new ClaimsIdentity(Request.GetOwinContext().Authentication.User.Identity);
string accessToken = identity.FindFirst("AccessToken").Value;
string userID = identity.FindFirst(ClaimTypes.NameIdentifier).Value;
GetUserDetailsRequest detailRequest = new GetUserDetailsRequest(connection, accessToken, new Guid(userID));
GetUserDetailsResponse model = detailRequest.Send();
if (model.StatusCode == System.Net.HttpStatusCode.OK)
{
return(View(model));
}
else
{
TempData["Errors"] = "There was an error processing your request";
return(View());
}
}
public IActionResult GetUserProfile()
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var isOperationSuccessful = Getemail(out var email);
if (!isOperationSuccessful)
{
return(NotFound());
}
var returnObject = new GetUserDetailsResponse();
var userMaster = Repo.GetUserMaster(email);
returnObject = Mapper.Map(userMaster, returnObject);
var userDetails = Repo.GetUserDetails(userMaster.UserId);
returnObject = Mapper.Map(userDetails, returnObject);
return(Ok(returnObject));
}
/**
* Get user details.
*/
public async Task <APIGatewayProxyResponse> GetUserDetails(IDataStores dataStores,
IDictionary <string, string> requestHeaders)
{
Debug.Untested();
Debug.AssertValid(dataStores);
Debug.AssertValid(requestHeaders);
try {
// Log call
LoggingHelper.LogMessage($"UserIdentityService::GetUserDetails()");
// Get the NoSQL DB client
AmazonDynamoDBClient dbClient = (AmazonDynamoDBClient)dataStores.GetNoSQLDataStore().GetDBClient();
Debug.AssertValid(dbClient);
// Check authenticated endpoint security
string loggedInUserId = await APIHelper.CheckLoggedIn(dbClient, requestHeaders);
Debug.AssertID(loggedInUserId);
// Perform logic
GetUserDetailsResponse response = await UserIdentityService_GetUserDetails_LogicLayer.GetUserDetails(dbClient, loggedInUserId);
Debug.AssertValid(response);
// Respond
return(new APIGatewayProxyResponse {
StatusCode = APIHelper.STATUS_CODE_OK,
Body = JsonConvert.SerializeObject(response)
});
//??--return Ok(response);
} catch (Exception exception) {
Debug.Tested();
return(APIHelper.ResponseFromException(exception));
}
}
public async Task <UserDetails> GetUserDetailsAsync(string userId)
{
GetUserDetailsResponse response = await RequestApiAsync <GetUserDetailsResponse>("get_user_details", new { id = userId });
return(response.User);
}
public void OnAuthentication(AuthenticationContext filterContext)
{
//Get current user
ClaimsPrincipal user = filterContext.HttpContext.User as ClaimsPrincipal;
if (user != null && user.Identity.IsAuthenticated)
{
ClaimsIdentity identity = new ClaimsIdentity(user.Identity);
DateTime expiresTime = DateTimeOffset.FromUnixTimeSeconds(long.Parse(identity.FindFirst(ClaimTypes.Expiration).Value)).LocalDateTime;
if (expiresTime < DateTime.Now)
{
string connection = ConfigurationManager.AppSettings["InternalAPIURL"];
string refreshToken = identity.FindFirst("RefreshToken").Value;
RefreshRequest refreshRequest = new RefreshRequest(connection, refreshToken);
RefreshResponse refreshResponse = refreshRequest.Send();
GetUserDetailsRequest userDetailRequest = new GetUserDetailsRequest(connection, refreshResponse.access_token, new Guid(refreshResponse.user_id));
GetUserDetailsResponse userDetailResponse = userDetailRequest.Send();
if (refreshResponse.StatusCode == System.Net.HttpStatusCode.OK && userDetailResponse.StatusCode == System.Net.HttpStatusCode.OK)
{
//Update the user's claims
identity.RemoveClaim(identity.FindFirst("AccessToken"));
identity.RemoveClaim(identity.FindFirst(ClaimTypes.Expiration));
identity.RemoveClaim(identity.FindFirst(ClaimTypes.Name));
identity.RemoveClaim(identity.FindFirst(ClaimTypes.NameIdentifier));
identity.AddClaim(new Claim("AccessToken", refreshResponse.access_token));
identity.AddClaim(new Claim(ClaimTypes.Expiration, refreshResponse.expireTime));
identity.AddClaim(new Claim(ClaimTypes.Name, refreshResponse.user_nick));
identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, refreshResponse.user_id));
var roleClaims = identity.FindAll(ClaimTypes.Role);
foreach (Claim role in roleClaims)
{
identity.RemoveClaim(role);
}
if (userDetailResponse.PERMISSIONS.Administrator)
{
identity.AddClaim(new Claim(ClaimTypes.Role, "Administrator"));
}
if (userDetailResponse.PERMISSIONS.Developer)
{
identity.AddClaim(new Claim(ClaimTypes.Role, "Developer"));
}
var authenticationManager = filterContext.HttpContext.GetOwinContext().Authentication;
authenticationManager.SignOut();
AuthenticationProperties properties = new AuthenticationProperties {
IsPersistent = Convert.ToBoolean(identity.FindFirst(ClaimTypes.IsPersistent).Value)
};
authenticationManager.SignIn(properties, identity);
ClaimsPrincipal claimsPrincipal = new ClaimsPrincipal(identity);
filterContext.HttpContext.User = claimsPrincipal;
}
else
{
filterContext.HttpContext.GetOwinContext().Authentication.SignOut();
}
}
}
else
{
filterContext.Result = new RedirectToRouteResult(new RouteValueDictionary {
{ "controller", "Account" }, { "action", "Login" }
});
}
}
public NegotiatedContentResult <GetUserDetailsResponse> PostGetUserDetails([FromBody] GetUserDetailsRequest request)
{
GetUserDetailsResponse resp = _userServices.GetUserDetails(request);
return(Content(HttpStatusCode.OK, resp));
}
public ActionResult Login(Login model)
{
if (ModelState.IsValid)
{
//make login request
string connection = ConfigurationManager.AppSettings["InternalAPIURL"];
LoginRequest loginRequest = new LoginRequest(connection, model.Email, model.password);
LoginResponse loginResponse = loginRequest.Send();
if (loginResponse.StatusCode == System.Net.HttpStatusCode.OK)
{
string accessToken = loginResponse.access_token;
Guid userID = new Guid(loginResponse.user_id);
GetUserDetailsRequest userDetailRequest = new GetUserDetailsRequest(connection, accessToken, userID);
GetUserDetailsResponse userDetailResponse = userDetailRequest.Send();
if (userDetailResponse.StatusCode == System.Net.HttpStatusCode.OK)
{
List <Claim> claims = new List <Claim>();
claims.Add(new Claim("AccessToken", loginResponse.access_token));
claims.Add(new Claim("RefreshToken", loginResponse.refresh_token));
claims.Add(new Claim(ClaimTypes.Name, loginResponse.user_nick));
claims.Add(new Claim(ClaimTypes.NameIdentifier, loginResponse.user_id));
claims.Add(new Claim(ClaimTypes.Expiration, loginResponse.expireTime));
claims.Add(new Claim(ClaimTypes.IsPersistent, model.RememberMe.ToString()));
if (userDetailResponse.PERMISSIONS.Administrator)
{
claims.Add(new Claim(ClaimTypes.Role, "Administrator"));
}
if (userDetailResponse.PERMISSIONS.Developer)
{
claims.Add(new Claim(ClaimTypes.Role, "Developer"));
}
ClaimsIdentity id = new ClaimsIdentity(claims, DefaultAuthenticationTypes.ApplicationCookie);
var authenticationManager = Request.GetOwinContext().Authentication;
AuthenticationProperties properties = new AuthenticationProperties {
IsPersistent = model.RememberMe
};
authenticationManager.SignIn(properties, id);
//redirect to register success, login success
TempData["Success"] = "You have successfully signed in!";
return(RedirectToAction("Index", "Account"));
}
else
{
TempData["Errors"] = "There was an error processing your request.";
return(View(model));
}
}
else
{
if (loginResponse.StatusCode == System.Net.HttpStatusCode.NotFound)
{
TempData["Errors"] = "Your email and password do not match. Please try again.";
}
else if (loginResponse.StatusCode == System.Net.HttpStatusCode.NotAcceptable)
{
TempData["Resend"] = model.Email;
}
else
{
TempData["Errors"] = "There was an error processing your request. Please try again.";
}
return(View(model));
}
}
else
{
return(View(model));
}
}
