/// <summary>
/// Register new component in problem instance
/// </summary>
/// <param name="networkAdapter"></param>
/// <param name="message"></param>
/// <param name="messageType"></param>
/// <param name="timout"></param>
public void HandleMessage(ServerNetworkAdapter networkAdapter, string message, MessageType messageType, TimeSpan timout)
{
Register msg = MessageSerialization.Deserialize<Register>(message);
if (msg == null || msg.SolvableProblems == null)// || msg.SolvableProblems.Where(p => p.ToLower().Contains("dvrp")).Count() == 0)
return;
DvrpProblem.WaitEvent.WaitOne();
ulong id = DvrpProblem.CreateComponentID();
DvrpProblem.ComponentsID.Add(id);
if (msg.Type == RegisterType.ComputationalNode)
{
DvrpProblem.Nodes.Add(id, msg);
}
else
{
DvrpProblem.Tasks.Add(id, msg);
DvrpProblem.ProblemsDividing.Add(id, new List<ulong>());
DvrpProblem.SolutionsMerging.Add(id, new List<ulong>());
}
DvrpProblem.ComponentsLastStatus.Add(id, DateTime.UtcNow);
RegisterResponse reponse = new RegisterResponse() { Id = id, Timeout = timout.ToString()};
networkAdapter.Send(reponse);
DvrpProblem.WaitEvent.Set();
}
private void RecieveRegisterResponse()
{
try
{
registerResponse = networkAdapter.Receive<RegisterResponse>(false);
}
catch (Exception)
{
Console.WriteLine("Cannot recieve RegisterResponse");
}
}
/// <summary>
/// common for TM and CN register response handler
/// e.g. assigns componentId, timeout, ...
/// (status sender thread)
/// </summary>
/// <param name="registerMessage"></param>
protected virtual void handleRegisterResponses(Register registerMessage)
{
Message[] requests = creator.Create(registerMessage);
Message[] responses = this.SendMessages(clusterClient, requests);
RegisterResponse registerResponse = null;
foreach (var response in responses)
{
switch (response.MessageType)
{
case MessageType.RegisterResponseMessage:
if (registerResponse != null)
{
throw new Exception("Multiple register responses");
}
log.Debug("RegisterResponse acquired: updating fields...");
registerResponse = response.Cast <RegisterResponse>();
break;
case MessageType.NoOperationMessage:
log.Debug("NoOperation acquired: updating backups");
UpdateBackups(response.Cast <NoOperation>());
break;
default:
throw new Exception("Invalid message delivered in register procedure "
+ response.ToString());
}
}
if (registerResponse == null)
{
throw new Exception("No register response ");
}
componentId = registerResponse.Id;
timeout = registerResponse.Timeout;
}
protected override async t.Task <bool> OnOkExecuting()
{
this.BeginLoading();
RegisterResponse response = await DXAPI.Register(page.Email, page.Password, page.UserName, null, UserRole.DeXign);
this.EndLoading();
switch (response.Status)
{
case APIResponseStatus.Success:
if (response.IsDuplicated)
{
page.SetEmailDuplicated();
page.emailBox.Focus();
return(false);
}
MessageBox.Show("회원 가입이 완료됬습니다!\r\n\r\n이메일 인증 후 로그인이 가능합니다.\r\n이메일을 확인해주세요.", "DeXign", MessageBoxButton.OK, MessageBoxImage.Information);
return(true);
case APIResponseStatus.InternalError:
MessageBox.Show("시스템 내부 오류", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
case APIResponseStatus.Failed:
MessageBox.Show($"오류: {response.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
case APIResponseStatus.Unknown:
MessageBox.Show("네트워크 오류", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
return(false);
}
public async Task <RegisterResponse> Register([FromBody] RegisterRequest model)
{
var response = new RegisterResponse
{
Message = "Não foi possível registrar o usuário",
Success = false
};
if (model.PasswordConf != model.Password)
{
response.Message = "A senha e confirmação da senha devem ser iguais";
}
if (model.Password.Length < 8)
{
response.Message = "A senha precisa conter no minimo 8 caracteres";
}
if (!ModelState.IsValid)
{
return(response);
}
var user = new ApplicationUser {
UserName = model.Username, Email = model.Username
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
response.Success = result.Succeeded;
response.Message = "Usuário registrado com sucesso";
}
return(response);
}
public async Task <bool> CompleteRegistration(string userName, string deviceResponse)
{
if (string.IsNullOrWhiteSpace(deviceResponse))
{
return(false);
}
User user = await FindUserByUsername(userName);
if (user?.AuthenticationRequest == null || user.AuthenticationRequest.Count == 0)
{
return(false);
}
RegisterResponse registerResponse = RegisterResponse.FromJson <RegisterResponse>(deviceResponse);
// TODO When the user is registration they should only ever have one auth request.????
AuthenticationRequest authenticationRequest = user.AuthenticationRequest.First();
StartedRegistration startedRegistration = new StartedRegistration(authenticationRequest.Challenge, authenticationRequest.AppId);
DeviceRegistration registration = Core.Crypto.U2F.FinishRegistration(startedRegistration, registerResponse);
user.AuthenticationRequest.Clear();
user.UpdatedOn = DateTime.Now;
user.DeviceRegistrations.Add(new Device
{
AttestationCert = registration.AttestationCert,
Counter = Convert.ToInt32(registration.Counter),
CreatedOn = DateTime.Now,
UpdatedOn = DateTime.Now,
KeyHandle = registration.KeyHandle,
PublicKey = registration.PublicKey
});
int result = await _dataContext.SaveChangesAsync();
return(result > 0);
}
public async Task <RegisterResponse> RegisterAsync(RegisterRequest request)
{
var result = new RegisterResponse {
Errors = new List <string>(), Succeed = false
};
var userExists = await _dbContext.Users.FirstOrDefaultAsync(mod => mod.Username == request.Username || mod.Email == request.Email) != null;
if (userExists)
{
result.Errors.Add("User arleady exists!");
return(result);
}
var model = new UserModel {
CreationDate = DateTime.UtcNow, Email = request.Email, Username = request.Username, Verified = false, HashedPassword = HashPassword(request.Password), UserProfile = new UserProfileModel()
};
_dbContext.Users.Add(model);
_dbContext.SaveChanges();
result.Succeed = true;
return(result);
}
private static bool TryLoadServerRegistration(out string serverId, out string serverToken)
{
serverId = null;
serverToken = null;
string serverIdPath = GetServerIdPath();
if (!File.Exists(serverIdPath))
{
return(false);
}
try
{
RegisterResponse registerResponse = JsonConvert.DeserializeObject <RegisterResponse>(File.ReadAllText(serverIdPath));
serverId = registerResponse.ServerId;
serverToken = registerResponse.ServerToken;
return(true);
}
catch (Exception arg)
{
Debug.LogError($"Failed to load companion server registration: {arg}");
return(false);
}
}
public async Task <IActionResult> Register([FromBody] RegisterRequest model)
{
var employee = new DbEmployee
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Office = model.Office
};
var result = await _userManager.CreateAsync(employee, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors.First().Description));
}
var responseId = new RegisterResponse {
Id = employee.Id
};
return(Ok(responseId));
}
private void CreateResponses()
{
_startedRegistration = new StartedRegistration(TestConts.SERVER_CHALLENGE_REGISTER_BASE64, TestConts.APP_ID_ENROLL);
_registerResponse = new RegisterResponse(TestConts.REGISTRATION_RESPONSE_DATA_BASE64,
TestConts.CLIENT_DATA_REGISTER_BASE64);
_deviceRegistration = new DeviceRegistration(
TestConts.KEY_HANDLE_BASE64_BYTE,
TestConts.USER_PUBLIC_KEY_AUTHENTICATE_HEX,
Utils.Base64StringToByteArray(TestConts.ATTESTATION_CERTIFICATE),
0);
_authenticateResponse = new AuthenticateResponse(
TestConts.CLIENT_DATA_AUTHENTICATE_BASE64,
TestConts.SIGN_RESPONSE_DATA_BASE64,
TestConts.KEY_HANDLE_BASE64);
_startedAuthentication = new StartedAuthentication(
TestConts.SERVER_CHALLENGE_SIGN_BASE64,
TestConts.APP_SIGN_ID,
TestConts.KEY_HANDLE_BASE64);
}
public async Task <RegisterResponse> Register(RegisterModel model)
{
var user = new ApplicationUser(model.Email);
var result = await this.userManager.CreateAsync(user);
var response = new RegisterResponse();
if (!result.Succeeded)
{
response.Succeeded = false;
foreach (var error in result.Errors)
{
response.Errors.Add($"{error.Code}: {error.Description}");
}
}
else
{
response.Succeeded = true;
}
return(response);
}
internal void HandleRegisterResponse(RegisterResponse register)
{
if (InvokeRequired)
{
Invoke(new MethodInvoker(() => HandleRegisterResponse(register)));
return;
}
if (register.Successful)
{
ChangeTab(MainIndex.Login);
UpdateStatus("Status: Registered.");
}
else
{
UpdateStatus("Status: Registration failed.");
}
if (register.Message != null)
{
MessageBox.Show(register.Message, "", MessageBoxButtons.OK, (MessageBoxIcon)register.ErrorCode);
}
}
public async Task <IActionResult> Register([FromBody] RegisterUserDto request)
{
if (User.Identity.IsAuthenticated)
{
return(StatusCode(StatusCodes.Status401Unauthorized));
}
if (ModelState.IsValid)
{
RegisterResponse response = new RegisterResponse();
var registrationResultUser = await this.identityService.RegisterUserAsync(request);
if (registrationResultUser != null)
{
response.Success = true;
response.Message = "Registration success";
}
return(Ok(response));
}
return(StatusCode(StatusCodes.Status400BadRequest));
}
public int Register(string username, string password, string nickname, out RegisterResponse registerResponse)
{
var client = new RestClient(ServerAddress.Address + "/api/register");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
var requestBody = new { username, password, nickname };
request.AddParameter("application/json", JsonConvert.SerializeObject(requestBody), ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
Console.WriteLine(response.Content);
registerResponse = JsonConvert.DeserializeObject <RegisterResponse>(response.Content);
if (registerResponse != null)
{
return(registerResponse.status);
}
else
{
registerResponse = null;
return(-20000);
}
}
void RegisterWithServer()
{
string endpoint;
if (this.whatAmI == playerType.plane)
{
endpoint = "/planes";
}
else
{
endpoint = "/monsters";
}
string url = this.ServerUrlBase + endpoint;
string info = this.sendServerCall(url, "POST", "");
RegisterResponse resp = JsonUtility.FromJson <RegisterResponse>(info);
if (resp.id != "")
{
this.selfId = resp.id;
}
}
public void SetUp()
{
_userRepository = new Mock <IUserRepository>();
_userRepository.Setup(x => x.CreateUser(It.IsAny <CreateUserRequest>())).Returns(new CreateUserResponse());
_userRepository.Setup(x => x.GetUser(It.IsAny <string>())).Returns(new GetUserResponse
{
User = new UserRecord
{
Username = "******",
Picture = "XuhV+MYOtWbMMMjlhD9qxg==",
UserToken = "P4rp8qs9/TEZP66ZYKNLvQ=="
}
});
_authenticator = new Mock <IAuthenticator>();
_authenticator.Setup(x => x.Authenticate(It.IsAny <IAuthenticationRequest>())).Returns(new BaseAuthenticationResponse
{
Username = "******",
Picture = "SOME_PICTURE",
UserId = "SOME_USER_ID"
});
_authenticationFactory = new Mock <IAuthenticatorFactory>();
_authenticationFactory.Setup(x => x.For(It.IsAny <Authenticator>())).Returns(_authenticator.Object);
;
var keyReader = new Mock <IKeyReader>();
keyReader.Setup(x => x.GetKey()).Returns("SOME_KEY");
var subject = new UserService(_userRepository.Object, _authenticationFactory.Object, new UserMapper(new AesEncryptor(keyReader.Object.GetKey())));
_result = subject.Register(new RegisterRequest
{
UserToken = "SOME_TOKEN",
Authenticator = Authenticator.Google
});
}
public async Task <RegisterResponse> RegisterAsync(RegisterRequest registerRequest, CancellationToken cancellationToken = default)
{
var messages = new List <string>();
var user = new User
{
Name = registerRequest.Name,
Email = registerRequest.Email,
UserName = registerRequest.Email
};
var result = await _authRespository.RegisterAsync(user, registerRequest.Password, cancellationToken);
if (result.Succeeded)
{
messages.Add("User Registered");
var registerResponse = new RegisterResponse
{
Name = registerRequest.Name,
Email = registerRequest.Email,
StatusCode = System.Net.HttpStatusCode.Created,
Messages = messages
};
return(registerResponse);
}
else
{
foreach (var error in result.Errors)
{
messages.Add(error.Description);
}
var registerResponse = new RegisterResponse
{
StatusCode = System.Net.HttpStatusCode.InternalServerError,
Messages = messages
};
return(registerResponse);
}
}
public override async void Post(HttpListenerContext ctx)
{
RegisterRequest request = await ReadJsonObject <RegisterRequest>(ctx.Request);
RegisterResponse response = new RegisterResponse();
string message;
if (String.IsNullOrWhiteSpace(request.Account) || String.IsNullOrWhiteSpace(request.Password))
{
message = String.Format("Could not create account ({0}), account or password empty", request.Account);
Logger.Error(message);
response.Success = false;
response.Message = message;
SendJsonObject(ctx.Response, response);
return;
}
string bCryptHash = BCrypt.Net.BCrypt.HashPassword(request.Password, ApiSettings.BCryptWorkFactor);
Account account = Database.CreateAccount(request.Account, bCryptHash);
if (account == null)
{
message = String.Format("Could not create account ({0}), account already exists", request.Account);
Logger.Error(message);
response.Success = false;
response.Message = message;
SendJsonObject(ctx.Response, response);
return;
}
message = String.Format("Created new account: {0}", request.Account);
Logger.Info(message);
response.Success = true;
response.Message = message;
SendJsonObject(ctx.Response, response);
}
protected void RegisterRequest(PacketHeader header, Connection connection, RegisterRequest account)
{
// ########################################################################
// This method requires authentication.
// If user is not authorized then send UnAuthorized and end method.
if (!Authorized(connection))
{
TCPConnection.GetConnection(connection.ConnectionInfo).SendObject(
PacketName.ReUnauthorized.ToString(), 1);
return;
}
// ########################################################################
if (Administrator(connection))
{
RegisterResponse response = RegisterResponse.Failure;
if (account.username.Length > 3 && account.password.Length > 3)
{
if (accountRepository.UsernameExist(account.username))
{
response = RegisterResponse.UsernameTaken;
}
else
{
accountRepository.Add(account.username, Security.PasswordHasher.HashPassword(account.password), account.firstname, account.lastname);
response = RegisterResponse.Success;
}
}
TCPConnection.GetConnection(connection.ConnectionInfo).
SendObject(PacketName.ReRegisterAccount.ToString(), (int)response);
}
}
public override Task <ProcessingResult> GetProcessingResult(RegisterResponse registerResponse, ServerCallContext context)
{
var config = new ConfigurationBuilder()
.SetBasePath(new DirectoryInfo(Directory.GetCurrentDirectory()).Parent.FullName + "/config")
.AddJsonFile("config.json", optional: false)
.Build();
string idResult = registerResponse.Id + "_rating";
var result = new ProcessingResult {
Status = "Processing", Response = "no response"
};
for (int i = 0; i < REQUEST_REPEATS; i++)
{
string response = getFromDB(idResult);
if (response != null)
{
result.Status = "Completed";
result.Response = response;
break;
}
Thread.Sleep(DELAY);
}
return(Task.FromResult(result));
}
private void BtnRegister_Click(object sender, EventArgs e)
{
//!Regex.IsMatch(txtRegisterEmail.Text, @"^\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$"))
if (dxRegisterValidationProvider.Validate())
{
RegisterResponse regRes = GlobalContext.Instance.AuthClient.Post(new Register()
{
FirstName = txtRegisterFirstName.Text,
LastName = txtRegisterLastName.Text,
DisplayName = $"{txtRegisterFirstName.Text} {txtRegisterLastName.Text }",
UserName = txtRegisterUserName.Text,
Email = txtRegisterEmail.Text,
Password = txtRegisterPassword1.Text,
ConfirmPassword = txtRegisterPassword2.Text,
AutoLogin = true,
});
//send of registration and move to login page
tabCtrlLoginRegister.SelectedTabPage = tabLogin;
tabRegister.PageVisible = false;
tabLogin.PageVisible = true;
//DialogResult = DialogResult.Yes;
}
}
public async Task <RegisterResponse> Register([FromBody] RegisterRequest request)
{
RegisterResponse response;
if (request == null)
{
response = new RegisterResponse();
response.SetError("Invalid register request");
return(response);
}
request.PublicId = Guid.NewGuid();
request.IP = _ipAddressParser.GetClientIp(HttpContext).ToString();
var registerResponse = await _accountServiceClient.User_Register(_mapper.Map <CreateUserRequest>(request));
response = new RegisterResponse()
{
HasError = registerResponse.HasError,
Message = registerResponse.Message,
Data = registerResponse.Data?.PublicId ?? Guid.Empty
};
return(response);
}
public override Task <RegisterResponse> Register(RegisterRequest request, ServerCallContext context)
{
string id = Guid.NewGuid().ToString();
var resp = new RegisterResponse {
Id = id
};
_jobs[id] = request.Description;
var model = new RedisModel {
Description = request.Description, Data = request.Data
};
string result = JsonSerializer.Serialize(model);
IDatabase db = _redis.GetDatabase();
db.StringSet(id, result);
string message = $"JobCreated|{id}";
byte[] payload = Encoding.Default.GetBytes(message);
_connection.Publish("events", payload);
return(Task.FromResult(resp));
}
public virtual void TestProcessRegistrationResponse_OneTransport()
{
mockDataStore.Setup(x => x.GetEnrollSessionData(SESSION_ID))
.Returns(new EnrollSessionData(ACCOUNT_NAME, APP_ID_ENROLL, SERVER_CHALLENGE_ENROLL));
var trustedCertificates = new List <X509Certificate>();
trustedCertificates.Add(TRUSTED_CERTIFICATE_ONE_TRANSPORT);
mockDataStore.Setup(x => x.GetTrustedCertificates()).Returns(trustedCertificates);
var u2FServer = new U2FServerReferenceImpl(mockChallengeGenerator.Object, mockDataStore.Object, crypto,
TRUSTED_DOMAINS);
var registrationResponse = new RegisterResponse(REGISTRATION_RESPONSE_DATA_ONE_TRANSPORT_BASE64,
BROWSER_DATA_ENROLL_BASE64, SESSION_ID);
u2FServer.ProcessRegistrationResponse(registrationResponse, 0L);
var transports = new List <SecurityKeyDataTransports>();
transports.Add(SecurityKeyDataTransports.BluetoothRadio);
var expectedKeyData = new SecurityKeyData(0L, transports, KEY_HANDLE, USER_PUBLIC_KEY_ENROLL_HEX,
TRUSTED_CERTIFICATE_ONE_TRANSPORT, 0);
mockDataStore.Verify(x => x.AddSecurityKeyData(ACCOUNT_NAME, expectedKeyData));
}
public virtual RegisterResponse Register(RegisterRequest registerRequest)
{
var registerResponse = new RegisterResponse();
if (string.IsNullOrEmpty(registerRequest.Email))
{
registerResponse.Errors.Add("Email address is not valid");
return(registerResponse);
}
if (string.IsNullOrEmpty(registerRequest.Password))
{
registerResponse.Errors.Add("Password is not valid");
return(registerResponse);
}
var customer = new Customer();
customer.Email = registerRequest.Email;
customer.Password = registerRequest.Password;
_customerRepository.Insert(customer);
return(registerResponse);
}
private byte[] Register_internal(string str)
{
RegisterResponse response = new RegisterResponse()
{
error = RegisterError.REGISTER_SUCCESS
};
bool genNew = true;
do
{
if (genNew)
{
response.id = GenRandomString();
genNew = false;
}
foreach (Client check in clients)
{
if (check.Id == response.id)
{
genNew = true;
}
}
}while (genNew);
Client newCl = new Client(response.id, str);
// generate random number of money! :)
newCl.Account = randDevice.Next(0, 4096);
clients.Add(newCl);
return(CreateMessage(ServerProtocol.svc_register, response.SerializeToByteArray()));
}
public bool CompleteRegistration(string userName, string deviceResponse)
{
if (string.IsNullOrWhiteSpace(userName) || string.IsNullOrWhiteSpace(deviceResponse))
{
return(false);
}
RegisterResponse registerResponse = RegisterResponse.FromJson(deviceResponse);
var user = _userRepository.FindUser(userName);
if (user == null || user.AuthenticationRequest == null)
{
return(false);
}
StartedRegistration startedRegistration = new StartedRegistration(user.AuthenticationRequest.Challenge, user.AuthenticationRequest.AppId);
DeviceRegistration registration = U2F.FinishRegistration(startedRegistration, registerResponse);
_userRepository.RemoveUsersAuthenticationRequest(userName);
_userRepository.AddDeviceRegistration(userName, registration.AttestationCert, registration.Counter, registration.KeyHandle, registration.PublicKey);
return(true);
}
public async Task <IActionResult> Register([FromBody] RegisterEntity model)
{
if (ModelState.IsValid)
{
var user = Utils.MapperApplicationUserToUserDataResponse(model);
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
var token = AuthenticationHelper.GenerateJwtToken(model.Email, user, _configuration);
var rootData = new RegisterResponse(token, user.UserName, user.Email);
return(Created("user/register", rootData));
}
return(BadRequest(result.Errors.ReturnErrorDetailsHandlingIdentityErrors()));
}
return(BadRequest(new ErrorDetails()
{
Message = Startup.StaticConfig["MessagesError:MissingFields"],
ErrorCode = Convert.ToInt32(Startup.StaticConfig["MessagesError:MissingFieldsErrorCode"])
}));
}
/// <summary>
/// 注册用户
/// </summary>
/// <returns></returns>
public string Register()
{
string returnStr = string.Empty;
if (Signature != GetParam("sig").ToString())
{
ErrorCode = (int)ErrorType.API_EC_SIGNATURE;
return returnStr;
}
if (CallId <= LastCallId)
{
ErrorCode = (int)ErrorType.API_EC_CALLID;
return returnStr;
}
if (!CheckRequiredParams("user_name,password,email"))
{
ErrorCode = (int)ErrorType.API_EC_PARAM;
return returnStr;
}
if (this.App.ApplicationType == (int)ApplicationType.DESKTOP)//如果是桌面程序则不允许此方法
{
if (Uid < 1 || Discuz.Forum.UserGroups.GetUserGroupInfo(Discuz.Forum.Users.GetShortUserInfo(Uid).Groupid).Radminid != 1)
{
ErrorCode = (int)ErrorType.API_EC_PERMISSION_DENIED;
return "";
}
}
else if (Uid > 0)//已经登录的用户不能再注册
{
ErrorCode = (int)ErrorType.API_EC_USER_ONLINE;
return returnStr;
}
string username = GetParam("user_name").ToString();
string password = GetParam("password").ToString();
string email = GetParam("email").ToString();
bool isMD5Passwd = GetParam("password_format") != null && GetParam("password_format").ToString() == "md5" ? true : false;
//用户名不符合规范
if (!CheckUsername(username))
{
ErrorCode = (int)ErrorType.API_EC_USERNAME_ILLEGAL;
return returnStr;
}
if (Discuz.Forum.Users.GetUserId(username) != 0)//如果用户名符合注册规则, 则判断是否已存在
{
ErrorCode = (int)ErrorType.API_EC_USER_ALREADY_EXIST;
return returnStr;
}
if (!isMD5Passwd && password.Length < 6)
{
ErrorCode = (int)ErrorType.API_EC_PARAM;
return returnStr;
}
if (!CheckEmail(email))
{
ErrorCode = (int)ErrorType.API_EC_EMAIL;
return returnStr;
}
UserInfo userInfo = new UserInfo();
userInfo.Username = username;
userInfo.Nickname = string.Empty;
userInfo.Password = isMD5Passwd ? password : Utils.MD5(password);
userInfo.Secques = string.Empty;
userInfo.Gender = 0;
userInfo.Adminid = 0;
userInfo.Groupexpiry = 0;
userInfo.Extgroupids = "";
userInfo.Regip = DNTRequest.GetIP();
userInfo.Joindate = Utils.GetDateTime();
userInfo.Lastip = DNTRequest.GetIP();
userInfo.Lastvisit = Utils.GetDateTime();
userInfo.Lastactivity = Utils.GetDateTime();
userInfo.Lastpost = Utils.GetDateTime();
userInfo.Lastpostid = 0;
userInfo.Lastposttitle = "";
userInfo.Posts = 0;
userInfo.Digestposts = 0;
userInfo.Oltime = 0;
userInfo.Pageviews = 0;
userInfo.Credits = 0;
userInfo.Extcredits1 = Scoresets.GetScoreSet(1).Init;
userInfo.Extcredits2 = Scoresets.GetScoreSet(2).Init;
userInfo.Extcredits3 = Scoresets.GetScoreSet(3).Init;
userInfo.Extcredits4 = Scoresets.GetScoreSet(4).Init;
userInfo.Extcredits5 = Scoresets.GetScoreSet(5).Init;
userInfo.Extcredits6 = Scoresets.GetScoreSet(6).Init;
userInfo.Extcredits7 = Scoresets.GetScoreSet(7).Init;
userInfo.Extcredits8 = Scoresets.GetScoreSet(8).Init;
userInfo.Email = email;
userInfo.Bday = string.Empty;
userInfo.Sigstatus = 0;
userInfo.Tpp = 0;
userInfo.Ppp = 0;
userInfo.Templateid = 0;
userInfo.Pmsound = 0;
userInfo.Showemail = 0;
userInfo.Salt = "0";
int receivepmsetting = Config.Regadvance == 0 ? 7 : 1;
userInfo.Newsletter = (ReceivePMSettingType)receivepmsetting;
userInfo.Invisible = 0;
userInfo.Newpm = Config.Welcomemsg == 1 ? 1 : 0;
userInfo.Medals = "";
userInfo.Accessmasks = 0;
userInfo.Website = string.Empty;
userInfo.Icq = string.Empty;
userInfo.Qq = string.Empty;
userInfo.Yahoo = string.Empty;
userInfo.Msn = string.Empty;
userInfo.Skype = string.Empty;
userInfo.Location = string.Empty;
userInfo.Customstatus = string.Empty;
userInfo.Bio = string.Empty;
userInfo.Signature = string.Empty;
userInfo.Sightml = string.Empty;
userInfo.Authtime = Utils.GetDateTime();
//邮箱激活链接验证
if (Config.Regverify == 1)
{
userInfo.Authstr = ForumUtils.CreateAuthStr(20);
userInfo.Authflag = 1;
userInfo.Groupid = 8;
Emails.DiscuzSmtpMail(username, email, string.Empty, userInfo.Authstr);
}
//系统管理员进行后台验证
else if (Config.Regverify == 2)
{
userInfo.Authstr = string.Empty;
userInfo.Groupid = 8;
userInfo.Authflag = 1;
}
else
{
userInfo.Authstr = "";
userInfo.Authflag = 0;
userInfo.Groupid = UserCredits.GetCreditsUserGroupId(0).Groupid;
}
userInfo.Realname = string.Empty;
userInfo.Idcard = string.Empty;
userInfo.Mobile = string.Empty;
userInfo.Phone = string.Empty;
if (Config.Passwordmode > 1 && PasswordModeProvider.GetInstance() != null)
{
userInfo.Uid = PasswordModeProvider.GetInstance().CreateUserInfo(userInfo);
}
else
{
userInfo.Uid = Discuz.Forum.Users.CreateUser(userInfo);
}
if (Config.Welcomemsg == 1)
{
PrivateMessageInfo privatemessageinfo = new PrivateMessageInfo();
// 收件箱
privatemessageinfo.Message = Config.Welcomemsgtxt;
privatemessageinfo.Subject = "欢迎您的加入! (请勿回复本信息)";
privatemessageinfo.Msgto = userInfo.Username;
privatemessageinfo.Msgtoid = userInfo.Uid;
privatemessageinfo.Msgfrom = PrivateMessages.SystemUserName;
privatemessageinfo.Msgfromid = 0;
privatemessageinfo.New = 1;
privatemessageinfo.Postdatetime = Utils.GetDateTime();
privatemessageinfo.Folder = 0;
PrivateMessages.CreatePrivateMessage(privatemessageinfo, 0);
}
Statistics.ReSetStatisticsCache();
//信息同步通知不会发向当前请求接口的应用程序，所以此处应保留，以支持论坛向其他关联应用程序发送通知
Sync.UserRegister(userInfo.Uid, userInfo.Username, userInfo.Password, ApiKey);
UserCredits.UpdateUserCredits(userInfo.Uid);
if (Format == FormatType.JSON)
return string.Format("\"{0}\"", userInfo.Uid);
RegisterResponse rr = new RegisterResponse();
rr.Uid = userInfo.Uid;
return SerializationHelper.Serialize(rr);
}
public RegisterResponse RegisterSocial(string sessionId, string socialAccountId, string socialAccountType,
string email, string firstName, string lastName, string mobile,
string ipAddress)
{
var response = new RegisterResponse();
using (new ApplicationContextScope(new ApplicationContext()))
{
ApplicationContext.SetSessionId(sessionId);
try
{
bool accountExists;
string authId;
bool isCaptchaValid;
IAccountProvider accountProvider = AccountProviderFactory.GetAccountProvider();
if (accountProvider.RegisterSocial(socialAccountId, socialAccountType, email, firstName, lastName,
mobile, ipAddress,
out authId, out accountExists))
{
response.FirstName = firstName;
response.IsSuccess = true;
response.AuthenticationId = authId;
response.IsEnabled = true;
}
else if (accountExists)
{
response.ErrorMessage = email +
" username already exists. Please login or click forgot password to reset the password.";
}
}
catch (Exception exception)
{
response.ErrorMessage = "Something is not quite right here. Please try again later.";
Logger.LogException(exception, Source, "Register", Severity.Critical);
}
}
return response;
}
public void Present(RegisterResponse response)
{
_authenticationService.SetToken(response.Token);
}
protected override string ReceivedRegister(Register register, IPAddress senderAddr)
{
string type = register.Type;
Node newNode;
ulong ID = RegisteredNodes.NextNodeID;
switch (Utilities.NodeTypeForName(type))
{
case NodeType.TaskManager:
newNode = new TaskManager();
if (senderAddr != null)
{
newNode.IP = senderAddr;
}
newNode.NodeType = Nodes.NodeType.TaskManager;
newNode.ID = register.Id;
this.RegisteredComponents.RegisterTaskManager(newNode);
break;
case NodeType.ComputationalNode:
newNode = new ComputationalNode();
newNode.ID = register.Id;
if (senderAddr != null)
{
newNode.IP = senderAddr;
}
newNode.NodeType = Nodes.NodeType.ComputationalNode;
this.RegisteredComponents.RegisterComputationalNode(newNode);
break;
case NodeType.Server:
newNode = new Server();
newNode.ID = ID;
BackupServerQueue bsq = new BackupServerQueue {
backupServerId = ID,
messages = new Queue <string>()
};
if (senderAddr != null)
{
newNode.IP = senderAddr;
}
newNode.NodeType = Nodes.NodeType.Server;
this.backupServerQueues.Add(bsq);
this.RegisteredComponents.RegisterBackupServer(newNode);
this.backupServerQueues.Add(bsq);
break;
case NodeType.Client: //not needed!
break;
default:
break;
}
//Register message is sent by TM, CN and Backup CS to the CS after they are activated.
RegisterResponse response = new RegisterResponse();
response.Id = ID;
response.Timeout = this.Timeout;
List <RegisterResponseBackupCommunicationServersBackupCommunicationServer> backupServers = new List <RegisterResponseBackupCommunicationServersBackupCommunicationServer>();
foreach (Node comp in this.RegisteredComponents.BackupServers)
{
RegisterResponseBackupCommunicationServersBackupCommunicationServer backup = new RegisterResponseBackupCommunicationServersBackupCommunicationServer();
if (comp.IP == null)
{
break;
}
backup.address = comp.IP.ToString();
if (comp.Port > 0)
{
backup.port = comp.Port;
backup.portSpecified = true;
}
backupServers.Add(backup);
}
response.BackupCommunicationServers = backupServers.ToArray();
if (!this.BackupMode)
{
Console.WriteLine("Sending RegisterResponse");
}
return(response.SerializeToXML());
}
public static void Log(this RegisterResponse registerResponse)
{
Console.WriteLine(registerResponse.GetType());
Console.WriteLine(registerResponse.ShipName);
Console.WriteLine();
}
protected bool Equals(RegisterResponse other)
{
return string.Equals(RegistrationData, other.RegistrationData) && string.Equals(Bd, other.Bd) &&
string.Equals(SessionId, other.SessionId);
}
static async Task Main(string[] args)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
List <Task> tasks = new List <Task>();
for (int j = 0; j < ClientCount; j++)
{
Task clientTask = Task.Run(async() =>
{
IMessageProcessor messageProcessor = new ClientMessageProcessor();
IMessageSerializer messageSerializer = new JsonMessageSerializer();
SslTcpNetworkConnector networkConnector = new SslTcpNetworkConnector(messageSerializer, messageProcessor, Host, Port);
await networkConnector.ConnectAsync(CancellationToken.None);
await networkConnector.AuthenticateAsClient(CancellationToken.None);
networkConnector.Start();
MessageListener <AuthenticateResponse> loginResponseListener = new MessageListener <AuthenticateResponse>();
MessageListener <RegisterResponse> registerMessageListener = new MessageListener <RegisterResponse>();
MessageListener <CreateTrainingRoomResponse> createTrainingRoomResponseListener = new MessageListener <CreateTrainingRoomResponse>();
MessageListener <GetEnabledTrainingRoomsResponse> getEnabledTrainingRoomsResponseListener = new MessageListener <GetEnabledTrainingRoomsResponse>();
MessageListener <StartTrainingSessionResponse> startTrainingSessionResponseListener = new MessageListener <StartTrainingSessionResponse>();
MessageListener <GetOrganismsResponse> getOrganismsResponseListener = new MessageListener <GetOrganismsResponse>();
MessageListener <PostOrganismsScoreResponse> postOrganismsScoreResponseListener = new MessageListener <PostOrganismsScoreResponse>();
loginResponseListener.Subscribe(messageProcessor);
createTrainingRoomResponseListener.Subscribe(messageProcessor);
registerMessageListener.Subscribe(messageProcessor);
getEnabledTrainingRoomsResponseListener.Subscribe(messageProcessor);
startTrainingSessionResponseListener.Subscribe(messageProcessor);
getOrganismsResponseListener.Subscribe(messageProcessor);
postOrganismsScoreResponseListener.Subscribe(messageProcessor);
for (int i = 0; i < MessageCount; i++)
{
Guid name = Guid.NewGuid();
RegisterRequest registerRequest = new RegisterRequest(name.ToString(), "password2", "Name2");
await networkConnector.SendMessageAsync(registerRequest, CancellationToken.None);
RegisterResponse registerResponse = await registerMessageListener.ReceiveMessageAsync(CancellationToken.None);
Console.WriteLine($"RegisterResponse: \n\tSuccess: {registerResponse.Success}, \n\tRequestId: {registerResponse.RequestId}, \n\tResponseId: {registerResponse.Id}, \n\tMessage:{registerResponse.Message}");
AuthenticateRequest loginRequest = new AuthenticateRequest(name.ToString(), "password2", "Name2");
await networkConnector.SendMessageAsync(loginRequest, CancellationToken.None);
AuthenticateResponse loginResponse = await loginResponseListener.ReceiveMessageAsync(CancellationToken.None);
Console.WriteLine($"AuthenticateResponse: \n\tSuccess: {loginResponse.Success}, \n\tAccessToken: {loginResponse.AccessToken}, \n\tRequestId: {loginResponse.RequestId}, \n\tResponseId: {loginResponse.Id}, \n\tMessage:{loginResponse.Message}");
TrainingRoomSettings trainingRoomSettings = new TrainingRoomSettings(50, 2, 1, 1, 1, 0.4, 3, 0.05, 0.03, 0.75, 0.001, 1, 0.8, 0.1, 0.5, 0.25, 0);
CreateTrainingRoomRequest createTrainingRoomRequest = new CreateTrainingRoomRequest(loginResponse.UserId, Guid.NewGuid().ToString(), trainingRoomSettings);
await networkConnector.SendMessageAsync(createTrainingRoomRequest, CancellationToken.None);
CreateTrainingRoomResponse createTrainingRoomResponse = await createTrainingRoomResponseListener.ReceiveMessageAsync(CancellationToken.None);
Console.WriteLine($"CreateTrainingRoomResponse: \n\tId: {createTrainingRoomResponse.Id}\n\tRequestId: {createTrainingRoomResponse.RequestId}\n\tDateTime: {createTrainingRoomResponse.DateTime}\n\tMessage: {createTrainingRoomResponse.Message}\n\tSuccess: {createTrainingRoomResponse.Success}\n\tTrainingRoomId: {createTrainingRoomResponse.TrainingRoomId}");
StartTrainingSessionRequest startTrainingSessionRequest = new StartTrainingSessionRequest(loginResponse.UserId, createTrainingRoomResponse.TrainingRoomId);
await networkConnector.SendMessageAsync(startTrainingSessionRequest, CancellationToken.None);
StartTrainingSessionResponse startTrainingSessionResponse = await startTrainingSessionResponseListener.ReceiveMessageAsync(CancellationToken.None);
Console.WriteLine($"StartTrainingSessionResponse: \n\tId: {startTrainingSessionResponse.Id}\n\tRequestId: {startTrainingSessionResponse.RequestId}\n\tDateTime: {startTrainingSessionResponse.DateTime}\n\tMessage: {startTrainingSessionResponse.Message}\n\tSuccess: {startTrainingSessionResponse.Success}\n\tTrainingSessionId: {startTrainingSessionResponse.TrainingSession.Id}");
await GetAndPostOrganismsAsync(startTrainingSessionResponse, networkConnector, getOrganismsResponseListener, postOrganismsScoreResponseListener);
await GetAndPostOrganismsAsync(startTrainingSessionResponse, networkConnector, getOrganismsResponseListener, postOrganismsScoreResponseListener);
await GetAndPostOrganismsAsync(startTrainingSessionResponse, networkConnector, getOrganismsResponseListener, postOrganismsScoreResponseListener);
await GetAndPostOrganismsAsync(startTrainingSessionResponse, networkConnector, getOrganismsResponseListener, postOrganismsScoreResponseListener);
await GetAndPostOrganismsAsync(startTrainingSessionResponse, networkConnector, getOrganismsResponseListener, postOrganismsScoreResponseListener);
//
await GetAndPostOrganismsAsync(startTrainingSessionResponse, networkConnector, getOrganismsResponseListener, postOrganismsScoreResponseListener);
//GetEnabledTrainingRoomsRequest getEnabledTrainingRoomsRequest = new GetEnabledTrainingRoomsRequest();
//await networkConnector.SendMessageAsync(getEnabledTrainingRoomsRequest, CancellationToken.None);
//GetEnabledTrainingRoomsResponse getEnabledTrainingRoomsResponse = await getEnabledTrainingRoomsResponseListener.ReceiveMessageAsync(CancellationToken.None);
//Console.WriteLine($"GetEnabledTrainingRoomsResponse: \n\tId: {getEnabledTrainingRoomsResponse.Id}\n\tRequestId: {getEnabledTrainingRoomsResponse.RequestId}\n\tDateTime: {getEnabledTrainingRoomsResponse.DateTime}\n\tMessage: {getEnabledTrainingRoomsResponse.Message}\n\tSuccess: {getEnabledTrainingRoomsResponse.Success}");
//foreach (TrainingRoomDto trainingRoomDto in getEnabledTrainingRoomsResponse.TrainingRooms)
// Console.WriteLine($"TrainingRoom:\n\tId: {trainingRoomDto.Id}\n\tName: {trainingRoomDto.Name}\n\tOwner: {trainingRoomDto.Owner.Username}");
}
loginResponseListener.Unsubscribe();
});
tasks.Add(clientTask);
}
await Task.WhenAll(tasks).ContinueWith(action =>
{
stopwatch.Stop();
Console.WriteLine($"Messages per second: {TotalMessages / stopwatch.Elapsed.TotalSeconds:N0}");
Console.ReadKey();
});
}
public RegisterResponse Register([FromBody]RegisterRequest request)
{
try
{
if (_playerRepo.Exists(x => x.Email.ToLowerInvariant() == request.Email.ToLowerInvariant()))
{
return new RegisterResponse() { ErrorCode = 1, ErrorMessage = "Die Email wurde bereits verwendet." };
}
var player = new Player();
player.Email = request.Email;
player.HomeAddress = request.HomeAddress;
player.WorkAddress = request.WorkAddress;
player.Phone = request.Phone;
player.Email = request.Email;
player.PasswordHash = GetMd5Hash(request.Password);
var image = Convert.FromBase64String(request.ImageBase64);
player.Image = ImageToByteArray(Resize(ByteArrayToImage(image), 279));
player.Nickname = request.Nickname;
InitPlayer(player);
player.LocationHistory = new List<PlayerLocation>();
// insert player
_playerRepo.Update(player);
AssignVictim(player);
RegisterResponse response = new RegisterResponse();
response.Player = _playerRepo.GetById(player.Id);
response.Hunter = response.Player.HunterId == null ? null : _playerRepo.GetById(response.Player.HunterId);
response.Victim = response.Player.VictimId == null ? null : _playerRepo.GetById(response.Player.VictimId);
return response;
}
catch (Exception ex)
{
return new RegisterResponse() { ErrorCode = 2, ErrorMessage = ex.Message };
}
}
