// 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);
}
}
