// Use this for initialization void Start() { IPAddress ip = IPAddress.Parse("127.0.0.1"); Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); try { clientSocket.Connect(new IPEndPoint(ip, 8885)); int receiveLength = clientSocket.Receive(result, result.Length, SocketFlags.None); Debug.Log("收到的长度receiveLength:" + receiveLength); Debug.Log("收到的长度result.Length:" + result.Length); for (int i = 0; i < receiveLength; i++) { print(result[i]); } MemoryStream ms = new MemoryStream(); ms.Write(result, 0, receiveLength); ms.Position = 0;//相当重要 SignUpResponse s = ProtoBuf.Serializer.Deserialize <SignUpResponse>(ms); Debug.Log("version:" + s.version); Debug.Log("错误代码:" + s.errorCode); Debug.Log("msg:" + System.Text.Encoding.UTF8.GetString(s.msg)); } catch (Exception e) { Debug.Log(e.ToString()); } }
public static void SignUpUser(SignUpPayload payload, ResponseCallback callback, ResponseFallback fallback) { HttpClient httpClient = new HttpClient(); Request request = new Request(HttpClient.Method.POST, Route.SIGNUP_ROUTE, payload); httpClient.Request( request, (statusCode, response) => { SignUpResponse signUpResponse = Deserialize(response); callback(signUpResponse); }, (statusCode, error) => { if (statusCode == StatusCodes.CODE_VALIDATION_ERROR) { ValidationError validationError = ErrorDeserilizer.DeserializeValidationErrorData(error); fallback(statusCode, validationError); } else { GenericError genericError = ErrorDeserilizer.DeserializeGenericErrorData(error); fallback(statusCode, genericError); } } ); }
public async Task <IActionResult> Register([FromBody] RegisterEntity model) { if (ModelState.IsValid) { var user = new Director { Name = model.Name, LastName = model.LastName, City = model.City, UserName = model.Email, Email = model.Email, PhoneNumber = model.PhoneNumber }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { await _userManager.AddToRoleAsync(user, "Director"); await _userManager.UpdateSecurityStampAsync(user); await _signInManager.SignInAsync(user, false); var token = AuthenticationHelper.GenerateJwtToken(model.Email, user, "Director", _configuration); var rootData = new SignUpResponse(token, user.UserName, user.Email); return(Created("api/director/register", rootData)); } return(Ok(string.Join(",", result.Errors?.Select(error => error.Description)))); } string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage)); return(BadRequest(errorMessage ?? "Bad Request")); }
public async Task <IActionResult> Register([FromBody] RegisterEntity model) { if (ModelState.IsValid) { var user = new ApplicationUser { Name = model.Name, LastName = model.LastName, City = model.City, UserName = model.Email, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { await _signInManager.SignInAsync(user, false); var token = BuildToken(user); var rootData = new SignUpResponse(token, user.UserName, user.Email); return(Created("api/v1/user/register", rootData)); } return(Ok(string.Join(",", result.Errors?.Select(error => error.Description)))); } string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage)); return(BadRequest(errorMessage ?? "Bad Request")); }
public async Task SignupUser(string username, string password, string email) { try { UserInfo.Clear(); UserInfo.UserName = username; UserInfo.Email = email; AmazonCognitoIdentityProviderClient provider = new AmazonCognitoIdentityProviderClient(new Amazon.Runtime.AnonymousAWSCredentials(), RegionEndpoint.EUCentral1); SignUpRequest signUpRequest = new SignUpRequest(); signUpRequest.ClientId = CLIENTAPP_ID; signUpRequest.Username = username; signUpRequest.Password = password; AttributeType attributeType1 = new AttributeType(); attributeType1.Name = "email"; attributeType1.Value = email; signUpRequest.UserAttributes.Add(attributeType1); SignUpResponse signUpResponse = await provider.SignUpAsync(signUpRequest); UserInfo.Verified = signUpResponse.UserConfirmed; } catch (Exception ex) { Console.WriteLine("SignupUser ERROR: " + ex.Message); throw ex; } }
/// <summary> /// Unmarshaller the response from the service to the response class. /// </summary> /// <param name="context"></param> /// <returns></returns> public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context) { SignUpResponse response = new SignUpResponse(); context.Read(); int targetDepth = context.CurrentDepth; while (context.ReadAtDepth(targetDepth)) { if (context.TestExpression("CodeDeliveryDetails", targetDepth)) { var unmarshaller = CodeDeliveryDetailsTypeUnmarshaller.Instance; response.CodeDeliveryDetails = unmarshaller.Unmarshall(context); continue; } if (context.TestExpression("UserConfirmed", targetDepth)) { var unmarshaller = BoolUnmarshaller.Instance; response.UserConfirmed = unmarshaller.Unmarshall(context); continue; } if (context.TestExpression("UserSub", targetDepth)) { var unmarshaller = StringUnmarshaller.Instance; response.UserSub = unmarshaller.Unmarshall(context); continue; } } return(response); }
public Response SignUp(SignUpRequest request) { try { SignUpResponse retval = new SignUpResponse(); var gu = _dal.GetUser(request.Email); var tblga = gu.Tables[0]; if (tblga.Rows.Count == 1) { retval = new SignUpUserNameAlreadyExists(); } else { var ds = _dal.CreateUser(request.Email, request.UserName); var tbl = ds.Tables[0]; if (tbl.Rows.Count == 1) { if (request.Email == (string)tbl.Rows[0][0] && request.UserName == (string)tbl.Rows[0][1]) { retval = new SignUpResponseOK((string)tbl.Rows[0][0], (string)tbl.Rows[0][1]); } } } return(retval); } catch (Exception ex) { return(new AppResponseError(ex.Message)); } }
public async Task <bool> SignUpAsync(string email, string password, string name, string surname) { object data = new { Email = email, Password = password, Name = name, SurName = surname }; string path = "/user"; var response = await RequestService.PostAsync(path, data, false); var result = new SignUpResponse(response); if (result.StatusCode.Equals(HttpStatusCode.OK)) { string message = "Hesabınız başarıyla oluşturuldu artık giriş yapabilirsiniz."; DependencyService.Get <IMessage>().ShowShortTime(message); } else { string message; if (result.Data.HasValue) { message = result.Data.Value.Message; } else { message = "Hesab oluşturulamadı lütfen tekrar deneyiniz."; } DependencyService.Get <IMessage>().ShowShortTime(message); } return(result.StatusCode.Equals(HttpStatusCode.OK)); }
private static async Task SignUpUser(string email, string password, string customerId) { IAmazonCognitoIdentityProvider provider = new AmazonCognitoIdentityProviderClient(new Amazon.Runtime.AnonymousAWSCredentials(), region); SignUpRequest signUpRequest = new SignUpRequest() { ClientId = appClientId, Username = email, Password = password }; List <AttributeType> attributes = new List <AttributeType>() { new AttributeType() { Name = "email", Value = email }, new AttributeType() { Name = "custom:stripeId", Value = customerId } }; signUpRequest.UserAttributes = attributes; try { SignUpResponse result = await provider.SignUpAsync(signUpRequest); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public AuthenticationConfirmUserTests() : base() { SignUpRequest signUpRequest = new SignUpRequest() { ClientId = pool.ClientID, Password = "******", Username = "******", UserAttributes = new List <AttributeType>() { new AttributeType() { Name = CognitoConstants.UserAttrEmail, Value = "*****@*****.**" }, }, ValidationData = new List <AttributeType>() { new AttributeType() { Name = CognitoConstants.UserAttrEmail, Value = "*****@*****.**" } } }; SignUpResponse signUpResponse = provider.SignUpAsync(signUpRequest).Result; AdminConfirmSignUpRequest confirmRequest = new AdminConfirmSignUpRequest() { Username = "******", UserPoolId = pool.PoolID }; AdminConfirmSignUpResponse confirmResponse = provider.AdminConfirmSignUpAsync(confirmRequest).Result; user = new CognitoUser("User5", pool.ClientID, pool, provider); }
public async Task <SignUpResponse> SignUpAsync(string email, string username, string password) { var client = new AmazonCognitoIdentityProviderClient(null, this.RegionEndpoint); SignUpRequest sr = new SignUpRequest(); sr.ClientId = this.ClientId; if (!string.IsNullOrEmpty(this.ClientSecret)) { sr.SecretHash = CalculateSecretHash(this.ClientId, this.ClientSecret, username); } sr.Username = username; sr.Password = password; sr.UserAttributes = new List <AttributeType> { new AttributeType { Name = "email", Value = email } }; try { SignUpResponse result = await client.SignUpAsync(sr); return(result); } catch (Exception ex) { throw; } }
public async Task <IActionResult> Register([FromBody] RegisterEntity model) { if (ModelState.IsValid) { var userRole = await _roleManager.FindByNameAsync("User"); if (userRole == null) { userRole = new ApplicationRole("User"); await _roleManager.CreateAsync(userRole); } var user = new ApplicationUser { Name = model.Name, LastName = model.LastName, City = model.City, UserName = model.Email, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); await _userManager.AddToRoleAsync(user, userRole.Name); if (result.Succeeded) { await _signInManager.SignInAsync(user, false); var token = await AuthenticationHelper.GenerateJwtToken(model.Email, user, _configuration, _userManager); var rootData = new SignUpResponse(token, user.UserName, user.Email); return(Created("api/authentication/register", rootData)); } return(Ok(string.Join(",", result.Errors?.Select(error => error.Description)))); } return(BadRequest(new ValidationProblemDetails(ModelState))); }
public static async Task <string> SignUp(string username, string password, string firstName, string lastName) { try { SignUpRequest signUpRequest = new SignUpRequest() { ClientId = AWS.ClientId, Password = password, Username = username }; AttributeType firstNameAttribute = new AttributeType() { Name = "given_name", Value = firstName }; AttributeType lastNameAttribute = new AttributeType() { Name = "family_name", Value = lastName }; signUpRequest.UserAttributes.Add(firstNameAttribute); signUpRequest.UserAttributes.Add(lastNameAttribute); SignUpResponse signUpResult = await App.provider.SignUpAsync(signUpRequest); return(signUpResult.UserSub); } catch (Exception e) { return("Error " + e.Message); } }
public SignUpResponse SignUp(string email, string username, string password, string passwordConfirm, string cityOfResidence) { SignUpResponse response = new SignUpResponse(); IAccountManager accountManager = new AccountManager(); if (password != passwordConfirm) { response.SignUpSuccessful = false; response.ErrorMessage = "Passwords do not match!"; } else { SignUpRequest request = new SignUpRequest() { Email = email, CityOfResidence = cityOfResidence, Password = password, ConfirmPassword = passwordConfirm, Username = username }; response = accountManager.SignUp(request); } return(response); }
public SignUpResponse SignUp(SignUpRequest request) { var response = new SignUpResponse() { ResponseStatus = ResponseStatus.Success }; try { var dtNow = DateTime.Now; var user = request.MapObject <User>(); user.Active = true; user.CreatedDate = dtNow; UserAccounService.SignUp(user, request.Password); response.Message = "Signup process completed succesfully"; } catch (ApplicationException ax) { response.ResponseStatus = ResponseStatus.Warning; response.Message = ax.Message; } catch (Exception ex) { response.ResponseStatus = ResponseStatus.Failur; response.Message = "Unable to complete the signup process"; } return(response); }
private static void AcceptClientConnect() { clientSocket = serverSocket.Accept(); if (clientSocket != null) { SignUpResponse s = new SignUpResponse(); s.errorCode = 0; s.version = 2; s.msg = System.Text.Encoding.UTF8.GetBytes("中文");; MemoryStream ms = new MemoryStream(); ProtoBuf.Serializer.Serialize <SignUpResponse>(ms, s); result = ms.ToArray(); for (int i = 0; i < result.Length; i++) { Console.WriteLine(result[i]); } ms.Close(); clientSocket.Send(result, result.Length, SocketFlags.None); string str = "长度:" + result.Length; Console.WriteLine(str); } Console.ReadLine(); }
// POST api/gateway/signup public async Task <IActionResult> SignUp([FromBody] RegistrationViewModel model) { if (!ModelState.IsValid) { BadRequest(ModelState); } //Prepare httpParameters for request HttpParameters httParameters = HttpParametersService.GetHttpParameters( model, ConfigHelper.AppSetting(Constants.ServerUrls, Constants.SignUp), HttpMethod.Post, string.Empty ); SignUpResponse signUpResult = await _gWService.PostTo <SignUpResponse>(httParameters); if (signUpResult.StatusCode == 422) { return(await ResponseService.GetResponse <UnprocessableEntityObjectResult, SignUpResponse>(signUpResult, ModelState)); } else if (signUpResult.StatusCode != 200) { return(await ResponseService.GetResponse <BadRequestObjectResult, SignUpResponse>(signUpResult, ModelState)); } return(new OkObjectResult(signUpResult)); }
public async Task <CognitoContext> SignUp(string userName, string password) { try { SignUpResponse result = await awsProvider.SignUpAsync(new SignUpRequest { ClientId = Keys.AWS_UsersPool_ClientID, Password = password, Username = userName }); Debug.WriteLine($"From {this.GetType().Name}, Sign Up Succeeded"); return(new CognitoContext(CognitoResult.SignupOk)); //ProceedToCodeValidation(); } catch (UsernameExistsException) { Debug.WriteLine($"From {this.GetType().Name}, UsernameExistsException"); return(new CognitoContext(CognitoResult.UserNameAlreadyUsed)); } catch (InvalidPasswordException) { Debug.WriteLine($"From {this.GetType().Name}, InvalidPasswordException"); return(new CognitoContext(CognitoResult.PasswordRequirementsFailed)); } catch (Exception e) { //Sign Up failed, reason below Debug.WriteLine($"Exception in: {this.GetType().Name} error:{e.Message}"); return(new CognitoContext(CognitoResult.Unknown, e.Message)); } }
public async Task <IActionResult> Register([FromBody] RegisterEntity model) { if (!ModelState.IsValid) { string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage)); return(BadRequest(errorMessage)); } var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(BadRequest(result.Errors)); } await _signInManager.SignInAsync(user, false); var token = AuthenticationHelper.GenerateJwtToken(user, _configuration); var rootData = new SignUpResponse(token, user.UserName, user.Email, user.Id); return(Ok(rootData)); }
private async Task <SignUpResponse> TrySignUpUser(ISignupModelUser user) { try { SignUpRequest request = GetSignUpRequest(user); AmazonCognitoIdentityProviderClient client = GetAmazonCognitoIdentity(); SignUpResponse response = await client.SignUpAsync(request); return(response); } catch (UsernameExistsException e) { throw new WebApiException(System.Net.HttpStatusCode.Forbidden, e.Message); } catch (InvalidPasswordException e) { throw new WebApiException(System.Net.HttpStatusCode.BadRequest, e.Message); } catch (InvalidParameterException e) { throw new WebApiException(System.Net.HttpStatusCode.BadRequest, e.Message); } catch (Exception e) { throw new WebApiException(System.Net.HttpStatusCode.InternalServerError, e.Message); } }
public async Task <IActionResult> Register([FromBody] RegisterEntity model) { if (ModelState.IsValid) { var user = new UserModel { FirstName = model.FirstName, LastName = model.LastName, UserName = model.Email, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { await _signInManager.SignInAsync(user, false); var token = AuthenticationHelper.GenerateJwtToken(model.Email, user, _config); var rootData = new SignUpResponse(token, user.UserName, user.Email); db.InsertRecord(tableName, user); return(Created("api/contacts/register", rootData)); } //db.InsertRecord(tableName, user); return(Ok(string.Join(",", result.Errors?.Select(error => error.Description)))); } string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage)); return(BadRequest(errorMessage ?? "Bad Request")); }
public SignUpResponse CallSignUpApi(object myBodyModel = null, HttpStatusCode expectedResponse = HttpStatusCode.OK) { _request.AddOrUpdatBody(myBodyModel); SignUpResponse response = ExecuteRequest <SignUpResponse>(); return(response); }
public void SignUpShouldFailForExistingUserName() { string userName = MethodBase.GetCurrentMethod().Name; User user = User.Create(userName); UserManager userProxy = new UserManager(); SignUpResponse result = userProxy.SignUp("*****@*****.**", userName, "password".Sha1(), false); Expect.IsFalse(result.Success, result.Message); }
public async Task <string> SignUpUser(ISignupModelUser userDTO) { // try signup user in aws cognito SignUpResponse response = await TrySignUpUser(userDTO); // if signup is successful then try add user to default group await TryAddUserToGroup(userDTO.Username); return(response.UserSub); }
public void CoreUsermanagerClientProxyTest() { Message.PrintLine("This test requires a heart server to be running on port 80 of the localhost", ConsoleColor.Yellow); ConsoleLogger logger = new ConsoleLogger() { AddDetails = false }; logger.StartLoggingThread(); // get proxies ProxyFactory factory = new ProxyFactory(); CoreClient coreClient = new CoreClient("Bam.Net", "CoreServicesTestApp", "localhost", 80, logger); UserRegistryService userService = coreClient.UserRegistryService; Expect.IsNotNull(userService); Expect.AreSame(coreClient, userService.Property("ApiKeyResolver")); Expect.AreSame(coreClient, userService.Property("ClientApplicationNameProvider")); bool? initFailed = false; coreClient.InitializationFailed += (o, a) => { initFailed = true; }; coreClient.Initialized += (o, a) => { initFailed = false; }; coreClient.RegisterApplicationProcess(); Expect.IsTrue(initFailed.Value); Expect.AreEqual("You must be logged in to do that", coreClient.Message); // sign up string email = $"{8.RandomLetters()}@threeheadz.com"; string userName = 5.RandomLetters(); string passHash = "password".Sha1(); SignUpResponse signupResponse = userService.SignUp(email, userName, passHash, false); Expect.IsTrue(signupResponse.Success, signupResponse.Message); if (!signupResponse.Success) { Message.PrintLine("Message: {0}", signupResponse.Message); } else { OutLine(signupResponse.TryPropertiesToString(), ConsoleColor.Cyan); } LoginResponse loginResponse = userService.Login(userName, passHash); Expect.IsTrue(loginResponse.Success, "Unable to login to userService"); string youSayIAm = userService.WhoAmI(); Expect.AreEqual(userName, youSayIAm); loginResponse = coreClient.ApplicationRegistryService.Login(userName, passHash); Expect.IsTrue(loginResponse.Success, "Unable to login to application registry service"); Expect.IsTrue(coreClient.RegisterApplicationProcess(), coreClient.Message); Expect.IsFalse(initFailed.Value); Expect.IsTrue(File.Exists(coreClient.ApiKeyFilePath)); Pass("No exceptions were thrown and all assertions passed"); }
public void SignUpShouldFailForExistingEmail() { UserManager user = new UserManager(); string emailAddress = "email@{0}.cxm"._Format(MethodBase.GetCurrentMethod().Name); string userName = "******".RandomLetters(6); User created = User.Create(userName, emailAddress, "password".Sha1()); SignUpResponse result = user.SignUp(emailAddress, userName, "password".Sha1(), false); Expect.IsFalse(result.Success); OutLine(result.Message); }
public void SignUpShouldSucceed() { UserManager user = new UserManager(); user.HttpContext = FakeItEasy.A.Fake <IHttpContext>(); SignUpResponse result = user.SignUp("*****@*****.**", "Test", "Password".Sha1(), false); Expect.IsNotNull(result.Success, "No Success value specified"); Expect.IsTrue(result.Success, "signup failed"); OutLine(result.Message); }
public async Task <bool> SignUpUser() { AmazonCognitoIdentityProviderClient provider = new AmazonCognitoIdentityProviderClient(new Amazon.Runtime.AnonymousAWSCredentials()); SignUpRequest signUpRequest = new SignUpRequest { ClientId = ConfigurationManager.AppSettings["CLIENT_ID"], Username = emailInput.Value, Password = passwordInput.Value }; AttributeType emailAttr = new AttributeType { Name = "email", Value = emailInput.Value }; signUpRequest.UserAttributes.Add(emailAttr); AttributeType givenNameAttr = new AttributeType { Name = "given_name", Value = firstNameInput.Value }; signUpRequest.UserAttributes.Add(givenNameAttr); AttributeType familyNameAttr = new AttributeType { Name = "family_name", Value = lastNameInput.Value }; signUpRequest.UserAttributes.Add(familyNameAttr); try { SignUpResponse result = await provider.SignUpAsync(signUpRequest); return(true); } catch (Exception ex) { var message = new JavaScriptSerializer().Serialize(ex.Message.ToString()); var script = string.Format("alert({0});", message); this.Page.ClientScript.RegisterStartupScript(this.GetType(), "ex", script, true); return(false); } }
public IActionResult SignUp([FromQuery] SignUpRequest request) { var account = mapper.Map <Account>(request); if (authService.SignUp(account, request.Password)) { var response = new SignUpResponse(true, request.Username); return(Json(response)); } return(Json(ErrorResponse.AccountExists)); }
public void SignUp() { UserInfo info = ServiceTools.GetUserInfo(); SignUpResponse response = _client.SignUp(info.Email, info.Password); if (!response.Success) { OutLine(response.Message, ConsoleColor.Magenta); } else { Message.PrintLine("{0} signed up successfully", info.Email); } }