public NodeRegResponse RegistrationAction(RegistrationMessage message)
{
var nodeMessage = new NodeRegMessage {
Message = message
};
NodeData worker;
var neighbors = Distributor.FormateNodeList(3, out worker);
nodeMessage.NeighBours = neighbors;
var serializedMessage = JsonConvert.SerializeObject(nodeMessage);
var content = new StringContent(serializedMessage, Encoding.UTF8, "application/json");
try
{
var response = worker.Sender.PostAsync(new Uri(new Uri(worker.IpAddress), "api/Register"), content).Result.Content.ReadAsStringAsync();
var responseFromNode = JsonConvert.DeserializeObject <NodeRegResponse>(response.Result);
return(responseFromNode);
}
catch (AggregateException e)
{
return(new NodeRegResponse {
Status = false, Message = "Eroare de connectare la server LB:" + e.InnerException.ToString(), ProcessedTime = DateTime.Now
});
}
}
private void OnRegistrMsg(RegistrationMessage message)
{
var answer = new RegistrationAnswerMessage();
if (message.UserName == string.Empty)
{
answer.Error = NetMsgErrorType.UserNameCannotBeEmpty;
}
else if (Storage.IsExist(message.UserName))
{
answer.Error = NetMsgErrorType.UserNameBusy;
}
else if (message.Password == string.Empty)
{
answer.Error = NetMsgErrorType.UserPasswordCannotBeEmpty;
}
if (!answer.HasError)
{
PlayerInfo playerData = new PlayerInfo
{
Autorziation = new PlayerAutorizationInfo(message.UserName, message.Password)
};
PlayerItemInfo defaultSkinItem = new PlayerItemInfo(GameItemType.SkinGreen, Storage.GetUniqueWorldId());
PlayerItemInfo defaultHelmetItem = new PlayerItemInfo(GameItemType.HelmetPropCap, Storage.GetUniqueWorldId());
playerData.Inventory.Items.Add(defaultSkinItem);
playerData.Inventory.EquipItem(defaultSkinItem);
playerData.Inventory.Items.Add(defaultHelmetItem);
playerData.Inventory.EquipItem(defaultHelmetItem);
Storage.Add(playerData);
}
SendAnswer(answer, message);
}
//Обработка запроса на регистрацию
private void HandleRegistration(RemoteClient client, RegistrationMessage registrationMessage)
{
//проверяем, есть ли в базе пользователь с таким имемен
var userWithSomwName = storage.Find(U => U.Name == registrationMessage.UserName);
//Если пользователь с таким именем есть в базе
if (userWithSomwName != null)
{
//Сообщаем клиенту, что такое имя занято
client.Send(new Response(StatusCode.UserNameBusy));
//И больше ничего не делаем
return;
}
//Имя пользователя не занято, создаем новый аккаунт
User user = new User
{
Name = registrationMessage.UserName,
Password = registrationMessage.UserPassword
};
//Сохраняем его в хранилище
storage.RegisterUser(user);
//И привызываем его к соединению, по которому пришел запрос на регистрацию
client.UserView = user;
//Отправяем клиенту инфу о том что он успешно зарегистрировался
client.Send(Response.GoodResponse);
}
private void OnRegistrationReceived(RegistrationMessage message)
{
var answer = new RegistrationAnswerMessage();
NetworkMessageErrorType errorType;
if (ValidateRegistrationMessage(message, out errorType))
{
PlayerInfo playerData = new PlayerInfo
{
AuthInfo = new PlayerAuthInfo(message.UserName, message.Password)
};
PlayerItemInfo defaultSkinItem = new PlayerItemInfo(GameItemType.SkinGreen, Storage.GetUniqueWorldId());
PlayerItemInfo defaultHelmetItem = new PlayerItemInfo(GameItemType.HelmetPropCap, Storage.GetUniqueWorldId());
playerData.Inventory.Items.Add(defaultSkinItem);
playerData.Inventory.EquipItem(defaultSkinItem);
playerData.Inventory.Items.Add(defaultHelmetItem);
playerData.Inventory.EquipItem(defaultHelmetItem);
Storage.Add(playerData);
}
else
{
answer.Error = errorType;
}
SendMessageToClient(answer, message.ConnectionId);
}
/// <summary>
/// Registration Implementation
/// </summary>
/// <param name="registration"></param>
/// <returns></returns>
internal async Task <RegistrationResponse> RegistrationAction(RegistrationMessage registration)
{
return(await Task.Run(async() =>
{
var regresp = new RegistrationResponse();
var data_req = JsonConvert.SerializeObject(registration);
var content = new StringContent(data_req, Encoding.UTF8, "application/json");
var handler = new HttpClientHandler();
handler.ServerCertificateCustomValidationCallback =
HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
handler.AllowAutoRedirect = true;
using (var client = new HttpClient(handler))
{
try
{
client.BaseAddress = new Uri("https://localhost:44380/");
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response = await client.PostAsync("api/Identity/Registration", content);
var data_resp = await response.Content.ReadAsStringAsync();
regresp = JsonConvert.DeserializeObject <RegistrationResponse>(data_resp);
}
catch (Exception e)
{
logger.Error(e, "Registration error");
}
return regresp;
}
}));
}
public async Task <bool> RegisterAsync([NotNull] string login, CancellationToken token = default)
{
if (login == null)
{
throw new ArgumentNullException(nameof(login));
}
var message = new RegistrationMessage()
{
Login = login
};
var deSerializedData = await GetDataAsync(message, token);
switch (deSerializedData)
{
case ErrorMessage errorMessage:
MessageBox.Show(errorMessage.Error);
return(false);
case SuccessfulMessage successfulMessage:
MessageBox.Show(successfulMessage.ToString());
return(true);
default:
throw new Exception();
}
}
private void MessageHandlerExecute(RegistrationMessage obj)
{
GcmClient.CheckDevice(this);
GcmClient.CheckManifest(this);
GcmClient.Register(this, PushHandlerBroadcastReceiver.SenderIds);
}
public override Task <Empty> DeregisterFile(RegistrationMessage request, ServerCallContext context)
{
var ip = context.GetHttpContext().Connection.RemoteIpAddress.ToString();
this.torrentFileManagerService.RemoveTorrentFile(request.File, ip, request.ClientPort);
return(Task.FromResult(new Empty()));
}
internal async Task <RegistrationResponse> RegistrationAction(RegistrationModel data)
{
var request = new RegistrationMessage();
request.IDNP = data.IDNP;
request.Name = data.Name;
request.Ip_address = data.Ip_address;
request.Surname = data.Surname;
request.Gender = data.Gender;
request.Birth_date = data.Birth_date;
request.Phone_Number = data.Phone_Number;
request.Email = data.Email;
request.RegisterDate = data.RegisterDate;
request.Region = data.Region;
var data_req = request.Serialize();
var content = new StringContent(data_req, Encoding.UTF8, "application/json");
var handler = new HttpClientHandler();
//handler.ClientCertificates.Add(cert);
handler.ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
handler.AllowAutoRedirect = true;
var client = new HttpClient(handler);
client.BaseAddress = new Uri("https://localhost:44383/");
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var request_api = new HttpRequestMessage()
{
RequestUri = new Uri("https://localhost:44383/api/Register"),
Method = HttpMethod.Post,
};
var response = client.PostAsync("api/Register", content);
// if (response.IsCompletedSuccessfully)
// {
try
{
var data_resp = await response.Result.Content.ReadAsStringAsync();
var datatype = JsonDocument.Parse(data_resp);
}
catch (AggregateException e)
{
}
return(null);
}
private RegistrationMessage CreateRegistrationMessage(FileInfo file)
{
var registrationMessage = new RegistrationMessage();
var sentFile = CreateSentFile(file);
registrationMessage.File = sentFile;
registrationMessage.ClientPort = configurationService.LocalServerPort;
return(registrationMessage);
}
private void SendRegistration()
{
var message = new RegistrationMessage
{
UserName = Settings.LoginGame,
Password = Settings.PasswordGame
};
Client.AppMsgReceived += OnAppMesgReceived;
Client.Send(message);
}
private void OnSignUpClicked()
{
FormView.ShowWaitingForm();
var message = new RegistrationMessage
{
UserName = FormView.LoginField.text,
Password = FormView.PasswordField.text
};
Client.Send(message);
}
static void Register(string username, string password)
{
IsConnecting = true;
client = new TcpClient(serverIpAddress, serverPort);
RegistrationMessage registrationMessage = new RegistrationMessage
{
ServerPassword = "******",
Username = username,
Password = password
};
StartReceiveDataThread();
SendMessage(JsonSerializer.Serialize(registrationMessage));
}
private void MessageHandlerExecute(RegistrationMessage obj)
{
if (UIDevice.CurrentDevice.CheckSystemVersion(8, 0))
{
var pushSettings = UIUserNotificationSettings.GetSettingsForTypes(
UIUserNotificationType.Alert | UIUserNotificationType.Badge | UIUserNotificationType.Sound,
new NSSet());
UIApplication.SharedApplication.RegisterUserNotificationSettings(pushSettings);
UIApplication.SharedApplication.RegisterForRemoteNotifications();
}
else
{
UIRemoteNotificationType notificationTypes = UIRemoteNotificationType.Alert | UIRemoteNotificationType.Badge | UIRemoteNotificationType.Sound;
UIApplication.SharedApplication.RegisterForRemoteNotificationTypes(notificationTypes);
}
}
public static async Task ProcessRegistrationsAndUnregistrations(
[QueueTrigger("WorkRegisteredQueue")] RegistrationMessage registrationMessage, [Table("Work")] CloudTable workTable,
[Table("WorkRegistry")] CloudTable workRegistryTable, TextWriter log,
[Queue("IpfsCoverImageProcessingQueue")] ICollector <string> ipfsImageProcesssinQueue)
{
var workProcessor = Bootstrap.InitialiseWorkDataLogProcessor(workTable, workRegistryTable, ipfsImageProcesssinQueue);
if (registrationMessage.Registered)
{
await workProcessor.ProcessFullUpsertAsync(registrationMessage.Address);
}
if (!registrationMessage.Registered)
{
await workProcessor.RemoveUnregisteredAsync(registrationMessage.Address);
}
}
private void CreateAndSendRegistrationMessage(string channel, ClientType clientType, RegistrationType registrationType)
{
var registrationMessage = new RegistrationMessage
{
User = _user,
Password = _pwd,
Channel = channel,
ClientType = clientType,
RegistrationType = registrationType
};
_sendMessageQueue.Enqueue(new Database.Message()
{
Channel = registrationMessage.Channel, ByteMessageString = Encoding.ASCII.GetString(registrationMessage.ToByteArray())
});
SendMessages();
}
public async Task <ActionResult> Registration(RegisterModel model)
{
ViewBag.State = false;
if (ModelState.IsValid)
{
var data = new RegistrationMessage();
data.IDNP = model.IDNP;
data.Name = model.Name;
data.Surname = model.Surname;
data.Gender = model.Gender;
data.Region = model.Region;
data.Email = model.Email;
data.Birth_date = DateTime.Parse(model.Birth_date);
data.RegisterDate = DateTime.Now;
data.Ip_address = Request.HttpContext.Connection.RemoteIpAddress.ToString();
data.Phone_Number = model.Phone_Number;
try
{
var response = await user.Registration(data);
if (response.Status == true)
{
ViewBag.Message = response.Message;
ViewBag.State = response.Status;
}
else
{
ModelState.AddModelError("", response.Message);
ViewBag.Message = response.Message;
ViewBag.State = response.Status;
}
return(View());
}
catch
{
return(View("Error"));
}
}
return(View(model));
}
public static void HandleRegistration(IMessage message, IConnection connection)
{
RegistrationMessage regMessage = message as RegistrationMessage;
if (regMessage.Password.IsEmpty())
{
connection.Send(MessageFactory.MakeAuthenticationResposeMessage("", Status.Error, "Пароль не может быть пустым."));
return;
}
try
{
Conn.InsertUser(regMessage.Login, Hash(regMessage.Password));
//SendToken(regMessage.Login, connection);
SendStatusOk(connection, "Вы успешно зарегестрировались!");
}
catch (Exception e)
{
connection.Send(MessageFactory.MakeAuthenticationResposeMessage("", Status.Error, e.Message));
}
}
//Регистрация пользователя
//Аргумент message будет выводиться в начале формы регистрации
//По умолчанию он равен Registration, и мы можем вызвать метод
//HandleRegister без аргументов.
//Если произошла какая-то ошибка при регистрации, это сообщение заменится на
//Информацию о произошедшей ошибке
private void HandleRegister(string message = "Registration")
{
//Создаем форму логина или регистрации
//У нас имеется одна форма, так как и для логина и для регистрации
//Нужно только два поля, ник и пароль
//Как аргумент - шапка формы
var registerWrapper = new LoginPasswordPairWrapper(message);
//Читаем пару логин/пароль, которые ввел пользователь
var pair = registerWrapper.GetPair();
//записываем эти данные в сообщение RegistrationMessage
//Для отправки на сервер
var registerMessage = new RegistrationMessage()
{
UserName = pair.Login,
UserPassword = pair.Password
};
//Отправляем сообщение на сервер
networkManager.SendMessage(registerMessage);
//Ждем от сервера ответа. На данном этапе нам мог прийти ответ только на это сообщение
var response = networkManager.GetResponse();
//В зависимости от кода результата делаем разные вещи
switch (response.StatusCode)
{
//Всё хорошо, юзер зареган, заканчиваем работу по регистрации в системе
case StatusCode.OK:
return;
//Произошла ошибка, введенное пользователем имя уже занято
case StatusCode.UserNameBusy:
//Снова вызываем метод для регистрации, но уже с новым сообщением в шапке
//Уже этот вызов должен будет решить проблему
HandleRegister($"Name {pair.Login} is busy");
return;
//Пришла какая-то дичь, роняем программу
default:
throw new Exception($"Status code is bad :( {response.StatusCode}");
}
}
private bool ValidateRegistrationMessage(RegistrationMessage message, out NetworkMessageErrorType errorType)
{
bool validationResult = true;
errorType = NetworkMessageErrorType.None;
if (string.IsNullOrEmpty(message.UserName))
{
errorType = NetworkMessageErrorType.UserNameCannotBeEmpty;
validationResult = false;
}
else if (Storage.IsExist(message.UserName))
{
errorType = NetworkMessageErrorType.UserNameBusy;
validationResult = false;
}
else if (string.IsNullOrEmpty(message.Password))
{
errorType = NetworkMessageErrorType.UserPasswordCannotBeEmpty;
validationResult = false;
}
return(validationResult);
}
public async Task <ActionResult <RegistrationResponse> > RegistrationAct([FromBody] RegistrationMessage registration)
{
return(await user.Registration(registration));
}
protected override void OnRecieved(object sender, BasicDeliverEventArgs ea)
{
var message = new RegistrationMessage(ea.Body.ToArray());
try
{
using (var scope = serviceScopeFactory.CreateScope())
{
var repositoryFactory = scope.ServiceProvider.GetRequiredService <IRepositoryFactory>();
if (message.Email.IsEmpty())
{
throw new ApplicationException("Email cannot be empty.");
}
var userEntity = new User
{
Email = message.Email,
};
using (var userRepository = repositoryFactory.CreateUserRepository())
using (var accountRepository = repositoryFactory.CreateAccountRepository())
using (var preferencesRepository = repositoryFactory.CreatePreferencesRepository())
using (var categoryRepository = repositoryFactory.CreateCategoryRepository())
{
userRepository.Add(userEntity);
userRepository.Commit();
accountRepository.Add(new Account
{
UserId = userEntity.Id,
Name = message.Language.IsNotEmpty() ? message.Language.Contains("en") ? "Cash" : "Efectivo" : "Cash",
AccountType = AccountType.Cash,
CurrencyId = 1
});
accountRepository.Commit();
var categories = CategoryRepository.GetDefaultCategories().Select(x => new Category
{
Id = x.Id,
Name = x.Name,
Icon = x.Icon,
IsActive = true,
Measurable = true,
UserId = userEntity.Id
}).ToList();
categoryRepository.Add(categories);
categoryRepository.Commit();
preferencesRepository.Add(new Preferences
{
UserId = userEntity.Id,
Key = "PreferredCurrency",
Value = "USD",
});
preferencesRepository.Add(new Preferences
{
UserId = userEntity.Id,
Key = "Language",
Value = message.Language,
});
preferencesRepository.Add(new Preferences
{
UserId = userEntity.Id,
Key = "EnableDailyBackups",
Value = true.ToString(),
});
preferencesRepository.Add(new Preferences
{
UserId = userEntity.Id,
Key = "EnableWeeklyEmails",
Value = true.ToString(),
});
preferencesRepository.Commit();
}
}
}
catch (Exception ex)
{
logger.LogError(ex, "Exception on creating new user data.");
}
}
internal async Task <RegistrationResponse> RegistrationAction(RegistrationMessage registration)
{
return(await Task.Run(async() =>
{
var config = new MapperConfiguration(cfg =>
cfg.CreateMap <RegistrationMessage, FiscData>());
var mapper = new Mapper(config);
var fiscregistration = mapper.Map <FiscData>(registration);
fiscregistration.BirthDate = registration.Birth_date;
//Verify if registration registration are valid.
using (var db = new SystemDBContext())
{
try
{
var fisc = await db.FiscData.FirstOrDefaultAsync(x =>
x.Idnp == fiscregistration.Idnp &&
x.Gender == fiscregistration.Gender &&
x.Region.Contains(fiscregistration.Region) &&
x.Surname == fiscregistration.Surname &&
x.Name == fiscregistration.Name &&
x.BirthDate == fiscregistration.BirthDate);
if (fisc == null)
{
return new RegistrationResponse {
Status = false, Message = "Datele introduse nu sunt correcte."
};
}
}
catch (Exception e)
{
logger.Error("Registration | " + registration.IDNP + " " + e.Message);
}
}
//Send registration to LoadBalancer
var content = new StringContent(JsonConvert.SerializeObject(registration), Encoding.UTF8, "application/json");
var clientCertificate = new X509Certificate2(Path.Combine(@"..\Certs", "administrator.pfx"), "ar4iar4i", X509KeyStorageFlags.Exportable);
var handler = new HttpClientHandler();
handler.ClientCertificates.Add(clientCertificate);
handler.ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
var regLbResponse = new NodeRegResponse();
using (var client = new HttpClient(handler))
{
try
{
client.BaseAddress = new Uri("https://localhost:44322/");
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response = client.PostAsync("api/Regist", content);
var registration_resp = await response.Result.Content.ReadAsStringAsync();
regLbResponse = JsonConvert.DeserializeObject <NodeRegResponse>(registration_resp);
}
catch (AggregateException e)
{
logger.Error("Registration |" + registration.IDNP + " " + e.Message);
return new RegistrationResponse {
Status = false, Message = "Error! Sistemul nu funcționează la moment reveniți mai târziu"
};
}
}
if (regLbResponse.Status == true)
{
///-------SEND EMAIL WITH PASSWORD------
EmailSender.Send(registration.Email, regLbResponse.VnPassword);
using (var db = new SystemDBContext())
{
var account = new IdvnAccount();
account.Idvn = regLbResponse.IDVN;
account.VnPassword = LoginHelper.HashGen(regLbResponse.VnPassword);
account.StatusNumber = "Non confirmed";
account.IpAddress = registration.Ip_address;
account.PhoneNumber = registration.Phone_Number;
account.Email = registration.Email;
account.Gender = registration.Gender;
account.Region = db.Regions.FirstOrDefault(m => m.RegionName == registration.Region);
db.Add(account);
try
{
db.SaveChanges();
}
catch (Exception e)
{
}
}
var random = new Random();
return new RegistrationResponse {
Status = true, ConfirmKey = random.Next(12452, 87620).ToString(), Message = "Înregistrare | IDNP: " + registration.IDNP + " a fost înregistrat.", IDVN = regLbResponse.IDVN, Email = registration.Email
};
}
else
{
return new RegistrationResponse {
Status = false, Message = "Înregistrare | IDNP: " + registration.IDNP + " nu a fost posibil de înregistrat"
};
}
}));
}
public async Task <ActionResult <RegLbResponse> > Register([FromBody] RegistrationMessage message)
{
var status = await _admin.Registration(message);
return(status);
}
public ActionResult <NodeRegResponse> Register([FromBody] RegistrationMessage message)
{
var status = _admin.RegistrationAction(message);
return(status);
}
public Task <RegLbResponse> Registration(RegistrationMessage message)
{
return(RegistrationAction(message));
}
public async Task Add(RegistrationMessage registrationMessage)
{
_registryProcessionQueue.Add(registrationMessage);
}
public async Task <RegistrationResponse> Registration(RegistrationMessage registration)
{
return(await RegistrationAction(registration));
}
