/// <summary>
/// Calls the appropriate method for each command
/// </summary>
/// <param name="command">The command to handle</param>
/// <param name="isAuthorised">If the user is authorised</param>
private void HandleCommand(Command command, bool isAuthorised)
{
// Extract the relevant portion of the command
switch (command.FirstWord)
{
case "x":
AddUsername(command);
break;
case "!x":
Usernames.Remove(command.Author.Username);
break;
case "!reset":
if (isAuthorised)
{
Usernames.Clear();
}
break;
case "!roster":
if (isAuthorised)
{
CreateRoster(command);
}
break;
}
}
/// <summary>
/// Formats the current information of this class into a string that can be posted in the channel
/// </summary>
/// <returns>The message to be posted as a string</returns>
private string FormMessage()
{
string message = $"• Attending next raid [{Usernames.Count}]:\n";
List <string> classes = ChannelConfig.ClassTypes;
foreach (var classVal in classes)
{
var myClass = Usernames.Where(x => x.Value == classVal);
if (!Roster.ContainsKey(classVal))
{
Roster[classVal] = 0;
}
if (myClass.Count() > 0 || Roster[classVal] > 0)
{
message += "|\t" + myClass.Count() + "/" + Roster[classVal] + "\t" + classVal.ToString() + ":\t";
foreach (var pair in myClass)
{
message += pair.Key;
if (pair.Key != myClass.Last().Key)
{
message += ", ";
}
}
message += "\n";
}
}
return(message);
}
public async void GetUsers()
{
foreach (var users in await Data.User.GetAllAsync())
{
Usernames.Add(users.UserName.Trim());
StudentNumbers.Add(users.StudentNumber.Trim());
Emails.Add(users.EmailAdress.Trim());
}
}
public override bool Equals(object obj)
{
var o = obj as UserTimetableList;
if (o != null)
{
return(Usernames.ListsAreIdentical(o.Usernames));
}
return(false);
}
public WorldRecordHolder(int id, string username, TimeSpan totalTimeHeld, TimeSpan longestTimeHeldConsecutively, int worldRecordCount, DateTime lastHeld)
{
ID = id;
Usernames.Add(username);
TotalTimeHeld = totalTimeHeld;
LongestTimeHeldConsecutively = longestTimeHeldConsecutively;
WorldRecordCount = worldRecordCount;
LastHeld = lastHeld;
MostRecentUsername = username;
}
public void Process(Context context)
{
var friends = context.Server.Database.QueryFriends(owner);
friends.ForEach(f =>
{
UserIds.Add(f.UserId);
Usernames.Add(f.Username);
Nicks.Add(f.Nickname);
});
}
public override void Process(XFireClient context)
{
var friends = context.Server.Database.QueryFriends(_ownerUser);
friends.ForEach(f =>
{
UserIds.Add(f.UserId);
Usernames.Add(f.Username);
Nicks.Add(f.Nickname);
});
}
/// <summary>
/// Returns total Amount of received Pictures
/// </summary>
public static long GetPictureAmountTotal()
{
try
{
return(Usernames.Sum(GetPictureAmountOfUser));
}
catch (Exception)
{
return(0);
}
}
public void AddUsername(string username)
{
if (Usernames == null)
{
Usernames = new List <string>();
}
if (!Usernames.Contains(username))
{
Usernames.Add(username);
}
}
public DatabaseUser AddUsername(string username)
{
if (Usernames == null)
{
Usernames = new List <string>();
}
if (!Usernames.Contains(username))
{
Usernames.Add(username);
}
return(this);
}
public override void Process(XFireClient context)
{
var usernames = context.Server.Database.QueryUsers(_queryByUsername).Select(a => a.Username).ToList();
Usernames.AddRange(usernames);
// Don't really care about these but they're necessary to work properly
var unknowns = usernames.Select(a => "Unknown").ToList();
FirstNames.AddRange(unknowns);
LastNames.AddRange(unknowns);
Emails.AddRange(unknowns);
}
private string GetUsersDescriptionString()
{
if (!Usernames.Any())
{
return("(no users entered)");
}
if (Usernames.Count == 1)
{
return(Usernames.Single());
}
return(String.Join(", ", Usernames.Take(Usernames.Count - 1)) + " or " + Usernames.Last());
}
public void Process(Context context)
{
var users = context.Server.Database.QueryUsers(queryByUsername);
var usernames = users.Select(a => a.Username);
Usernames.AddRange(usernames);
// Don't really care about these but they're necessary to work properly
var unknowns = usernames.Select(a => "Unknown");
FirstNames.AddRange(unknowns);
LastNames.AddRange(unknowns);
Emails.AddRange(unknowns);
}
private async void fetchUsername()
{
App.Current.Dispatcher.Invoke(delegate
{
Usernames.Clear();
});
ObservableCollection <UserLobby> usernames = new ObservableCollection <UserLobby>();
try
{
var response = await ServerService.instance.client.GetAsync(Constants.SERVER_PATH + Constants.USERS_LOBBY_PATH + LobbyName);
if (response.IsSuccessStatusCode)
{
StreamReader streamReader = new StreamReader(await response.Content.ReadAsStreamAsync());
String responseData = streamReader.ReadToEnd();
var myData = JsonConvert.DeserializeObject <List <String> >(responseData);
foreach (var item in myData)
{
App.Current.Dispatcher.Invoke(delegate
{
usernames.Add(new UserLobby(item, item == ServerService.instance.username));
if (Bots.Contains(item))
{
Bots.Remove(item);
}
});
}
Usernames = usernames;
string firstUser = findFirstNotBot(Usernames);
IsGameMaster = ServerService.instance.username == firstUser;
}
else if (!response.IsSuccessStatusCode)
{
var message = await response.Content.ReadAsStringAsync();
ErrorServerMessage serverMessage = JsonConvert.DeserializeObject <ErrorServerMessage>(message);
ShowMessageBox(serverMessage.message);
}
}
catch (Exception e)
{
ShowMessageBox(e.Message);
}
}
public void AddName(string name)
{
Check.NotNull(name);
if (Username == name)
{
return;
}
Log.Info($"User updated username: {Username} => {name} ({Id})");
Username = name;
var newUsername = new Username {
User = this,
Date = DateTimeOffset.Now,
Name = Username
};
Usernames.Add(newUsername);
}
public void AddFriendInvitation(string username, string nickname, string message)
{
Usernames.Add(username);
Nicknames.Add(nickname);
Messages.Add(message);
}
public void SaveGame(GameData GameData)
{
using (ConverterGameDBEntities entities = new ConverterGameDBEntities())
{
var usernamesDbList = from u in entities.Usernames
where u.Username == GameData.Username
select u;
Usernames username;
bool exist = false;
if (usernamesDbList.ToArray().Length > 0)
{
exist = true;
username = usernamesDbList.ToArray()[0];
}
else
{
exist = false;
username = new Usernames()
{
Username = GameData.Username
};
}
int lastId = entities.Games.ToArray().Length;
Game game = new Game()
{
Username = username,
Id = lastId + 1
};
username.Games.Add(game);
int lastGameId = entities.GameDatas.ToArray().Length;
Collection <Enterprise_Development_CW1.DB.GameData> gameData = new Collection <DB.GameData>();
foreach (GameState state in GameData.GameStates)
{
lastGameId++;
string fromType = "";
string toType = "";
switch (state.From)
{
case ValueType.Decimal:
fromType = "Decimal";
break;
case ValueType.Binary:
fromType = "Binary";
break;
case ValueType.Hexadecimal:
fromType = "Hexadecimal";
break;
default:
fromType = "";
break;
}
switch (state.To)
{
case ValueType.Decimal:
toType = "Decimal";
break;
case ValueType.Binary:
toType = "Binary";
break;
case ValueType.Hexadecimal:
toType = "Hexadecimal";
break;
default:
toType = "";
break;
}
gameData.Add(new DB.GameData()
{
FromType = fromType,
ToType = toType,
FromValue = state.FromVal,
ToValue = state.ToVal,
Game = game,
GameString = state.GameString,
Id = lastGameId
});
}
game.GameDatas = gameData;
if (!exist)
{
entities.Usernames.Add(username);
}
try {
entities.SaveChanges();
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Value: \"{1}\", Error: \"{2}\"",
ve.PropertyName,
eve.Entry.CurrentValues.GetValue <object>(ve.PropertyName),
ve.ErrorMessage);
}
}
throw;
}
}
}
public virtual void AddFields(IEnumerable <Field> fields)
{
if (fields == null)
{
return;
}
// Add the fields to their corresponding container.
foreach (Field field in fields)
{
if (field.GetType() == typeof(Data.Fields.Name))
{
Names.Add((Data.Fields.Name)field);
}
else if (field.GetType() == typeof(Address))
{
Addresses.Add((Address)field);
}
else if (field.GetType() == typeof(Phone))
{
Phones.Add((Phone)field);
}
else if (field.GetType() == typeof(Email))
{
Emails.Add((Email)field);
}
else if (field.GetType() == typeof(Job))
{
Jobs.Add((Job)field);
}
else if (field.GetType() == typeof(Education))
{
Educations.Add((Education)field);
}
else if (field.GetType() == typeof(Image))
{
Images.Add((Image)field);
}
else if (field.GetType() == typeof(Username))
{
Usernames.Add((Username)field);
}
else if (field.GetType() == typeof(UserID))
{
UserIDs.Add((UserID)field);
}
else if (field.GetType() == typeof(DOB))
{
DOB = (DOB)field;
}
else if (field.GetType() == typeof(Gender))
{
Gender = (Gender)field;
}
else if (field.GetType() == typeof(Language))
{
Languages.Add((Language)field);
}
else if (field.GetType() == typeof(Ethnicity))
{
Ethnicities.Add((Ethnicity)field);
}
else if (field.GetType() == typeof(OriginCountry))
{
OriginCountries.Add((OriginCountry)field);
}
else if (field.GetType() == typeof(URL))
{
Urls.Add((URL)field);
}
}
}
public override string ToString()
{
return(string.Format("[UserTimetableList: Usernames={0}, LastOpenedTimetable={1}]", Usernames.Aggregate("", (c, o) => c + o), LastOpenedTimetable));
}
public override int GetHashCode()
{
return((Usernames.Aggregate("", (current, s) => current + s)).GetHashCode());
}
/// <summary>
/// Removes the current user assigned AdminUserName and Updates the adminUsername property to the current (next) in the collection.
/// </summary>
public void UpdateAdmin()
{
_usernames.Remove(AdminUserName);
AdminUserName = Usernames.ElementAt(0);
}
private void textBox1_TextChanged(object sender, TextChangedEventArgs e)
{
if (ReplacingNow)
{
return;
}
if (!WordStart)
{
foreach (TextChange change in e.Changes)
{
if (change.AddedLength > 0)
{
switch (textBoxContent.Text.Substring(change.Offset, 1))
{
case " ":
case ",":
case ".":
case ":":
case ";":
case "(":
case ")":
case "!":
case "?":
case "\"":
WordStart = true;
UsernameStarted = false;
HashtagStarted = false;
break;
default:
WordStart = false;
break;
}
if (WordStart)
{
break;
}
}
}
}
if (UsernameStarted || HashtagStarted)
{
foreach (TextChange change in e.Changes)
{
if (change.AddedLength > 0)
{
switch (textBoxContent.Text.Substring(change.Offset, 1))
{
case " ":
case ",":
case ".":
case ":":
case ";":
case "(":
case ")":
case "!":
case "?":
case "\"":
WordStart = true;
UsernameStarted = false;
HashtagStarted = false;
break;
default:
WordStart = false;
break;
}
if (WordStart)
{
break;
}
}
}
}
if (WordStart && (!UsernameStarted && !HashtagStarted))
{
foreach (TextChange change in e.Changes)
{
if (change.AddedLength > 0)
{
if (textBoxContent.Text.Substring(change.Offset, 1) == " ")
{
WordStart = true;
continue;
}
else
{
WordStart = false;
}
if (textBoxContent.Text.Substring(change.Offset, 1) == "@")
{
UsernameStarted = true;
StartPosition = change.Offset;
CurrentText = "";
}
else if (textBoxContent.Text.Substring(change.Offset, 1) == "#")
{
HashtagStarted = true;
StartPosition = change.Offset;
CurrentText = "";
}
}
}
}
if (UsernameStarted)
{
foreach (TextChange change in e.Changes)
{
if (change.AddedLength > 0)
{
CurrentText += textBoxContent.Text.Substring(change.Offset, change.AddedLength);
}
else if (change.RemovedLength > 0)
{
if (change.RemovedLength >= CurrentText.Length)
{
UsernameStarted = false;
CurrentText = "";
MatchingTexts.Clear();
popupMatchingUsernames.IsOpen = false;
return;
}
else if (change.RemovedLength == CurrentText.Length)
{
WordStart = true;
CurrentText = "";
popupMatchingUsernames.IsOpen = false;
MatchingTexts.Clear();
}
else
{
CurrentText = CurrentText.Substring(0, CurrentText.Length - change.RemovedLength);
}
}
}
if (Usernames.Where(name => name.ToLower().StartsWith(CurrentText.ToLower())).Count() > 0)
{
MatchingTexts.Clear();
foreach (string username in Usernames.Where(name => name.ToLower().StartsWith(CurrentText.ToLower())))
{
MatchingTexts.Add(username);
if (MatchingTexts.Count >= Properties.Settings.Default.MaxNumberOfEntriesInAutocomplete)
{
break;
}
}
popupMatchingUsernames.PlacementRectangle = textBoxContent.GetRectFromCharacterIndex(textBoxContent.CaretIndex, true);
popupMatchingUsernames.IsOpen = true;
}
else
{
MatchingTexts.Clear();
popupMatchingUsernames.IsOpen = false;
}
}
else if (HashtagStarted)
{
foreach (TextChange change in e.Changes)
{
if (change.AddedLength > 0)
{
CurrentText += textBoxContent.Text.Substring(change.Offset, change.AddedLength);
}
else if (change.RemovedLength > 0)
{
if (change.RemovedLength >= CurrentText.Length)
{
HashtagStarted = false;
CurrentText = "";
MatchingTexts.Clear();
popupMatchingUsernames.IsOpen = false;
return;
}
else if (change.RemovedLength == CurrentText.Length)
{
WordStart = true;
CurrentText = "";
popupMatchingUsernames.IsOpen = false;
MatchingTexts.Clear();
}
else
{
CurrentText = CurrentText.Substring(0, CurrentText.Length - change.RemovedLength);
}
}
}
if (Hashtags.Where(tag => tag.ToLower().StartsWith(CurrentText.ToLower())).Count() > 0)
{
MatchingTexts.Clear();
foreach (string hashtag in Hashtags.Where(tag => tag.ToLower().StartsWith(CurrentText.ToLower())))
{
MatchingTexts.Add(hashtag);
if (MatchingTexts.Count >= Properties.Settings.Default.MaxNumberOfEntriesInAutocomplete)
{
break;
}
}
popupMatchingUsernames.PlacementRectangle = textBoxContent.GetRectFromCharacterIndex(textBoxContent.CaretIndex, true);
popupMatchingUsernames.IsOpen = true;
}
else
{
MatchingTexts.Clear();
popupMatchingUsernames.IsOpen = false;
}
}
}
public override int GetHashCode()
{
return(Usernames != null ? Usernames.GetHashCode() : 0);
}
