public async Task <IActionResult> RegisterApplicant([FromBody] RegistrationViewModel model)
{
var user = await _registrationService.RegisterAsync(model, IdentityConfig.DefaultRoles.APPLICANT);
if (ModelState.ErrorCount <= 0)
{
var @applicantEvent = new ApplicantsChanged
{
Created = new[] { Mapper.Map <DtoUser>(user) }
};
var @userEvent = new UsersChanged(applicantEvent);
_eventBus.Publish(@applicantEvent);
_eventBus.Publish(@userEvent);
var url = _cryptoService.Decrypt(model.ReturnUrl);
return(Ok(url));
}
var errorsJson = new JsonErrorResponse
{
Messages = ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage)
.ToArray()
};
var errors = new BadRequestObjectResult(errorsJson);
return(BadRequest(errors));
}
public void AddTargetUser(string newTargetUser)
{
if (!_messages.ContainsKey(newTargetUser))
{
_messages.Add(newTargetUser, new List <Message>());
UsersChanged?.Invoke();
}
}
public void AddUser(TwitterUser user)
{
if (_users.TryAdd(user.Id, user))
{
_context.Add(user);
_context.SaveChanges();
UsersChanged?.Invoke(this, new UserChangedEventArgs(user, null));
}
}
public void AddUser(string name, string email, Bitmap picture)
{
if (KnownUsers.ToList().Any(u => u.HasIdentity(new LibGit2Sharp.Identity(name, email))))
{
return;
}
KnownUsers.Add(new User(FindNextName(), name, email, picture));
UsersChanged?.Invoke();
}
public static void Update(int id, User modifiedUser)
{
var found = Context.Users.Find(id);
found?.Update(modifiedUser);
Context.SaveChanges();
UsersChanged?.Invoke();
}
public void EditUser(User user)
{
var index = Users.FindIndex(p => p.Email == user.Email);
Users[index].Name = user.Name;
Users[index].Surname = user.Surname;
SaveChanges();
UsersChanged?.Invoke(Users);
}
public async Task SignOutUser()
{
if (User != null)
{
_hubConnection.Remove($"newMessage-{User.UserName}");
await _hubConnection.StopAsync();
}
User = null;
_messages = new Dictionary <string, List <Message> >();
UsersChanged?.Invoke();
}
private void MessageReceived(Message message)
{
var sourceUser = message.SourceUserName;
if (!_messages.ContainsKey(sourceUser))
{
_messages.Add(sourceUser, new List <Message>());
UsersChanged?.Invoke();
}
_messages[sourceUser].Add(message);
NewMessage?.Invoke(sourceUser);
}
public bool RemoveUser(TwitterUser user)
{
if (_users.TryRemove(user.Id, out _))
{
user = _context.Find <TwitterUser>(user.Id);
_context.Remove(user);
_context.SaveChanges();
UsersChanged?.Invoke(this, new UserChangedEventArgs(null, user));
return(true);
}
return(false);
}
private async Task RetrieveMessages()
{
if (User != null)
{
var messages = await Http.GetJsonAsync <IEnumerable <Message> >($"{Configuration["API_URL_PART_GetMessages"]}/{User.UserName}");
if (messages != null)
{
Console.WriteLine($"Received {messages.Count()} messages");
_messages = messages.GroupBy(m => m.TargetUserName != User.UserName ? m.TargetUserName : m.SourceUserName).ToDictionary(g => g.Key, g => g.OrderBy(e => e.DateTime).ToList());
UsersChanged?.Invoke();
}
}
}
public static void Register(string first, string last, string username, string password, byte[] picture, List <Role> roles)
{
User user = new User()
{
FirstName = first,
LastName = last,
Username = username,
Password = password,
AccountPicture = picture,
Roles = roles
};
Context.Users.Add(user);
Context.SaveChanges();
UsersChanged?.Invoke();
}
public void RemoveUser(User user)
{
if (user.ID == null)
{
throw new NullIdException("User ID is null.");
}
removeUser.Parameters["@ID"].Value = user.ID;
try
{
connection.Open();
if (removeUser.ExecuteNonQuery() == 0)
{
throw new ZeroRowsExecutedException();
}
}
finally
{
Close();
removeUser.Parameters["@ID"].Value = DBNull.Value;
}
UsersChanged?.Invoke();
}
public void DeleteUser(User user)
{
Users.Remove(user);
SaveChanges();
UsersChanged?.Invoke(Users);
}
public void AddUser(User user)
{
Users.Add(user);
SaveChanges();
UsersChanged?.Invoke(Users);
}
private void onUsersChanged()
{
UsersChanged?.Invoke(this, EventArgs.Empty);
}
public async Task RunAsync(CancellationToken stoppingToken)
{
var buffer = new ArraySegment <byte>(new byte[2048]);
await _webSocket.ConnectAsync(new Uri("ws://localhost:50080/connect"), CancellationToken.None);
while (!stoppingToken.IsCancellationRequested)
{
WebSocketReceiveResult received;
using MemoryStream data = new MemoryStream();
do
{
received = await _webSocket.ReceiveAsync(buffer, stoppingToken);
Console.WriteLine("Received {0} b ({1})", received.Count, received.EndOfMessage);
await data.WriteAsync(buffer.Slice(0, received.Count));
} while (!received.EndOfMessage);
var type = GetType(data);
switch (type)
{
case NotificationType.UserChanged:
{
var userNotification = UserChangedNotification.Parser.ParseFrom(data);
UsersChanged?.Invoke(this, new UserChangedEventArgs(userNotification));
break;
}
case NotificationType.QueueChanged:
{
var notification = QueueChangedNotification.Parser.ParseFrom(data);
QueueChanged?.Invoke(this, new ItemsChangedEventArgs(notification));
break;
}
case NotificationType.ItemsChanged:
{
var notification = QueueChangedNotification.Parser.ParseFrom(data);
ItemsChanged?.Invoke(this, new ItemsChangedEventArgs(notification));
break;
}
case NotificationType.ItemPlayed:
{
var notification = ItemPlayedNotification.Parser.ParseFrom(data);
ItemPlayed?.Invoke(this, new ItemPlayedEventArgs(notification));
break;
}
default:
Console.WriteLine("Unknown Type \"{0}\"", type);
break;
}
}
await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Bye", CancellationToken.None);
NotificationType GetType(MemoryStream data)
{
try
{
data.Seek(0, SeekOrigin.Begin);
var item = NotificationItem.Parser.ParseFrom(data);
Console.WriteLine("Parsed `NotificationItem`: {0}", item != null);
data.Seek(0, SeekOrigin.Begin);
return(item.Type);
}
catch (Exception e)
{
return(NotificationType.None);
}
}
}
internal void OnMessage(IrcMessage message)
{
switch (message.Command)
{
case "353":
foreach (string user in message.Arguments[3].Split(' '))
{
users.Add(user);
}
break;
case "366":
UsersChanged?.Invoke(this);
break;
case "PRIVMSG":
ReceiveMessage(message);
break;
case "ROOMSTATE":
ReceiveRoomState(message);
break;
case "USERNOTICE":
switch (message.Tags.FirstOrDefault(t => t.Key == "msg-id")?.Value)
{
case "raid":
ReceiveRaidNotice(message);
break;
case "sub":
case "resub":
case "charity":
ReceiveUserNotice(message);
break;
default:
Logger.Warning(this, "Unknown user message type", message.ToString());
break;
}
break;
case "JOIN":
ReceiveJoin(message);
break;
case "PART":
ReceivePart(message);
break;
case "HOSTTARGET":
ReceiveHostTarget(message);
break;
case "NOTICE":
ReceiveNotice(message);
break;
case "USERSTATE":
ReceiveUserState(message);
break;
}
}
