// Constructor To Bind the backend part to the UserControl
public Schedule(UserInfo user, int index, HouseRules houseRules, Form parent)
{
InitializeComponent();
this.parent = (StudentForm)parent;
scheduleItem = new ScheduleItem(user, index, houseRules);
change = false;
if (houseRules.AllRules[index].LastCompleted == DateTime.Today && user.ID != houseRules.AllRules[index].CurrentStudentId)
{
DoneBox.Enabled = true;
DoneBox.Checked = true;
this.BackColor = Color.LightGreen;
}
else if (GetDays() == 0)
{
DoneBox.Enabled = true;
DoneBox.Checked = false;
this.BackColor = Color.LightBlue;
}
else
{
DoneBox.Enabled = false;
DoneBox.Checked = false;
this.BackColor = Color.LightGray;
}
change = true;
}
// Constructor that sets some info on the object correct in the instance variables
public ScheduleItem(UserInfo user, int index, HouseRules houseRules)
{
this.houseRules = houseRules;
this.houseRule = houseRules.AllRules[index];
this.dateTimeBuffer = this.houseRule.LastCompleted;
this.index = index;
int timesUntilNextAppointment;
if (houseRules.AllRules[index].LastCompleted == DateTime.Today && user.ID != houseRules.AllRules[index].CurrentStudentId)
{
timesUntilNextAppointment = 0;
}
else if (user.ID == houseRules.AllRules[index].CurrentStudentId)
{
timesUntilNextAppointment = 1;
}
else
{
int current = houseRule.CurrentStudentId;
timesUntilNextAppointment = Math.Abs(user.ID - current);
if (timesUntilNextAppointment < 0)
{
timesUntilNextAppointment += houseRule.OrderOfStudents.Count;
}
timesUntilNextAppointment += 1;
}
this.ID = houseRule.CurrentStudentId;
span = houseRule.LastCompleted.AddDays(timesUntilNextAppointment * houseRule.Interval).Subtract(DateTime.Today);
}
// Constructor to make the adminform connect to the server
// Sees if the server sends "updated", if so: updates
public AdminForm(ServerConnection server, int houseNumber, UserInfo user)
{
InitializeComponent();
Task.Run(() =>
{
udpClient.Client.Bind(new IPEndPoint(0, server.GetAvailableUdpPort()));
int attempts = 0;
string message = "";
while (true)
{
Thread.Sleep(200);
int count = udpClient.Client.Available;
byte[] msg = new byte[count];
if (msg.Length == 0 && attempts < 100)
{
continue;
}
else if (attempts >= 100)
{
}
else if (msg.Length == 0)
{
continue;
}
if (attempts < 100)
{
udpClient.Client.Receive(msg);
message = Encoding.Default.GetString(msg, 0, msg.Length);
}
if (message.Contains("Updated") || attempts >= 100)
{
_user.StudentsInfo = server.GetUsersInfo(_user.HouseNumber);
_mandatoryRules = server.GetMandatoryRules(_user.HouseNumber);
_houseRules = server.GetHouseRules(_user.HouseNumber);
_complaints = server.GetComplaints(_user.HouseNumber);
_messages = server.GetMessages(_user.HouseNumber);
}
;
attempts = 0;
}
});
_houseNumber = houseNumber;
_server = server;
_mandatoryRules = server.GetMandatoryRules(houseNumber);
_houseRules = server.GetHouseRules(houseNumber);
_complaints = server.GetComplaints(houseNumber);
_messages = server.GetMessages(houseNumber);
_user = user;
UpdateTick(false);
}
public AddComplainStudent(HouseRules houseRules, MandatoryRules mandatoryRules, UserInfo user, Form form)
{
InitializeComponent();
this.parent = (StudentForm)form;
this.houseRules = houseRules;
this.mandatoryRules = mandatoryRules;
this.user = user;
cbAnon.Checked = false;
}
public bool UpdateHouseRules(HouseRules houseRules)
{
Wait(25);
string json = JsonConvert.SerializeObject(houseRules, Formatting.Indented);
string message = GetResponce(PackageType.UPDATE_HOUSE_RULES, PackageType.RECEIVED, json);
return(true);
}
// Updates the HouseRules
private void UpdateHouseRulesLayout(HouseRules hr, bool showUpdate)
{
pnlHouseRules.SuspendLayout();
pnlHouseRules.Controls.Clear();
foreach (HouseRule rule in hr.AllRules)
{
AddHouseRule(rule, hr.AllRules.IndexOf(rule));
}
pnlHouseRules.ResumeLayout();
}
// Sets the task as being undone (for mistake purposes)
public void SetUnDone(HouseRules hr)
{
houseRule.LastCompleted = dateTimeBuffer.Subtract(TimeSpan.FromDays(houseRule.Interval));
houseRule.CurrentStudentId -= 1;
if (houseRule.CurrentStudentId < 1)
{
houseRule.CurrentStudentId = houseRule.OrderOfStudents.Count() - 1;
}
hr.AllRules[index] = this.houseRule;
serverConnection.UpdateHouseRules(hr);
}
// Sets the task as being done
public void SetDone(HouseRules hr)
{
dateTimeBuffer = houseRule.LastCompleted;
houseRule.LastCompleted = DateTime.Today;
houseRule.CurrentStudentId += 1;
if (houseRule.CurrentStudentId > houseRule.OrderOfStudents.Count())
{
houseRule.CurrentStudentId = houseRule.OrderOfStudents[0];
}
hr.AllRules[index] = this.houseRule;
serverConnection.UpdateHouseRules(hr);
}
public async Task <IActionResult> Create(
[Bind("Name, Type, MaxTraveler, Description")] Accommodation accommodation,
[Bind("StreetAndNumber, Complement, City, PostalCode, Country")] Address address,
[Bind("ArrivalHour, DepartureHour, PetAllowed, PartyAllowed, SmokeAllowed")] HouseRules houseRules)
{
if (!ModelState.IsValid)
{
return(View(accommodation));
}
accommodation.UserId = (await _userManager.GetUserAsync(User)).Id;
accommodation.Address = address;
accommodation.HouseRules = houseRules;
_context.Add(accommodation);
await _context.SaveChangesAsync();
return(RedirectToAction("ManagePictures", "Picture", new { id = accommodation.Id }));
}
public async Task <IActionResult> Edit(Guid id,
[Bind("Id, Name, Type, MaxTraveler, Description")] Accommodation accommodation,
[Bind("Id, StreetAndNumber, Complement, City, PostalCode, Country")] Address address,
[Bind("Id, ArrivalHour, DepartureHour, PetAllowed, PartyAllowed, SmokeAllowed")] HouseRules houseRules)
{
if (id != accommodation.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(accommodation));
}
// Get accommodation's user
accommodation.UserId = await _context.Accommodations.Where(a => a.Id == id).Select(a => a.UserId).SingleOrDefaultAsync();
accommodation.Address = address;
accommodation.HouseRules = houseRules;
try
{
_context.Update(accommodation);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AccommodationExists(accommodation.Id))
{
return(NotFound());
}
throw;
}
return(RedirectToAction("Edit", new { id }));
}
public SecretHitler(SecretHitlerConfig config, Channel mainChannel, IList <User> users, HouseRules house = HouseRules.None)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (mainChannel == null)
{
throw new ArgumentNullException(nameof(mainChannel));
}
if (users == null)
{
throw new ArgumentNullException(nameof(users));
}
_state = GameState.Setup;
_config = config;
_channel = mainChannel;
_players = new List <Player>();
_houseRules = house;
int fas = 0;
switch (users.Count)
{
case 5:
case 6:
fas = 2;
break;
case 7:
case 8:
fas = 3;
break;
case 9:
case 10:
fas = 4;
break;
default:
break;
}
for (int i = 0; i < 16; i++)
{
users = (List <User>)users.Shuffle();
}
foreach (var user in users)
{
if (_players.Count == 0)
{
_players.Add(new Player(user, _config.FascistParty, _config.Hitler));
}
else if (_players.Count(p => p.Party == _config.FascistParty) < fas)
{
_players.Add(new Player(user, _config.FascistParty, _config.Fascist));
}
else
{
_players.Add(new Player(user, _config.LiberalParty, _config.Liberal));
}
}
for (int i = 0; i < 32; i++)
{
_players = (List <Player>)_players.Shuffle();
}
//_allPlayers = _players.Select(p => p.User.Id).ToArray();
LiberalTrack = new List <BoardSpace>
{
new BoardSpace(BoardSpaceType.Blank),
new BoardSpace(BoardSpaceType.Blank),
new BoardSpace(BoardSpaceType.Blank),
new BoardSpace(BoardSpaceType.Blank),
new BoardSpace(BoardSpaceType.LiberalWin)
};
FascistTrack = new List <BoardSpace>();
switch (_players.Count)
{
case 5:
case 6:
FascistTrack.Add(new BoardSpace(BoardSpaceType.Blank));
FascistTrack.Add(new BoardSpace(BoardSpaceType.Blank));
FascistTrack.Add(new BoardSpace(BoardSpaceType.Examine));
break;
case 7:
case 8:
FascistTrack.Add(new BoardSpace(BoardSpaceType.Blank));
FascistTrack.Add(new BoardSpace(BoardSpaceType.Investigate));
FascistTrack.Add(new BoardSpace(BoardSpaceType.ChooseNextCandidate));
break;
case 9:
case 10:
FascistTrack.Add(new BoardSpace(BoardSpaceType.Investigate));
FascistTrack.Add(new BoardSpace(BoardSpaceType.Investigate));
FascistTrack.Add(new BoardSpace(BoardSpaceType.ChooseNextCandidate));
break;
default:
break;
}
FascistTrack.Add(new BoardSpace(BoardSpaceType.Execution));
FascistTrack.Add(new BoardSpace(BoardSpaceType.ExecutionVeto));
FascistTrack.Add(new BoardSpace(BoardSpaceType.FascistWin));
Deck = new Stack <PolicyType>(
Enumerable.Repeat(PolicyType.Fascist, 11)
.Concat(Enumerable.Repeat(PolicyType.Liberal, 6)));
for (int i = 0; i < 32; i++)
{
Deck = new Stack <PolicyType>(Deck.Shuffle());
}
_channel.Client.MessageReceived += ProcessMessage;
PropertyChanged += PropChanged;
//_timer = new Timer(cb =>
//{
//},
//null,
//Timeout.Infinite,
//10000);
}
//Updates information about all rules in the form
public void RulesUpdateTick(bool showUpdate = true)
{
//Chacks mandatory rules
if (mandatoryRules.AllRules.Count != pnlMandatoryRules.Controls.Count / 2)
{
pnlMandatoryRules.SuspendLayout();
pnlMandatoryRules.Controls.Clear();
foreach (MandatoryRule rule in mandatoryRules.AllRules)
{
AddMandatoryRule(rule, mandatoryRules.AllRules.IndexOf(rule));
}
pnlMandatoryRules.ResumeLayout();
}
//Checks house rules
if (houseRules.AllRules.Count != pnlHouseRules.Controls.Count / 3 + pnlNotifications.Controls.Count / 4)
{
pnlNotifications.Controls.Clear();
pnlNotifications.SuspendLayout();
pnlHouseRules.SuspendLayout();
pnlHouseRules.Controls.Clear();
int approved = 0;
int disapproved = 0;
foreach (HouseRule rule in houseRules.AllRules)
{
if (rule.ApprovalState == false)
{
AddNotificationsRule(rule, houseRules.AllRules.IndexOf(rule), disapproved);
disapproved++;
}
else
{
AddHouseRule(rule, houseRules.AllRules.IndexOf(rule), approved);
approved++;
}
}
pnlNotifications.ResumeLayout();
pnlHouseRules.ResumeLayout();
}
HouseRules hr = houseRules.Clone();
for (int i = 0; i < hr.AllRules.Count; i++)
{
int numberOfApprovals = 0;
for (int j = 0; j < student.TotalStudentNumber; j++)
{
numberOfApprovals += Convert.ToInt32(hr.AllRules[i].StudentsApproval[j + 1]);
}
if (numberOfApprovals > student.TotalStudentNumber / 2)
{
if (hr.AllRules[i].ApprovalState == false)
{
hr.AllRules[i].ApprovalState = true;
pnlNotifications.SuspendLayout();
pnlNotifications.Controls.Clear();
pnlHouseRules.SuspendLayout();
pnlHouseRules.Controls.Clear();
int approved = 0;
int disapproved = 0;
foreach (HouseRule rule in hr.AllRules)
{
if (rule.ApprovalState == false)
{
AddNotificationsRule(rule, hr.AllRules.IndexOf(rule), disapproved);
disapproved++;
}
else
{
AddHouseRule(rule, hr.AllRules.IndexOf(rule), approved);
approved++;
}
}
pnlNotifications.ResumeLayout();
pnlHouseRules.ResumeLayout();
}
}
else
{
if (hr.AllRules[i].ApprovalState == true)
{
hr.AllRules[i].ApprovalState = false;
pnlNotifications.SuspendLayout();
pnlNotifications.Controls.Clear();
pnlHouseRules.SuspendLayout();
pnlHouseRules.Controls.Clear();
int approved = 0;
int disapproved = 0;
foreach (HouseRule rule in hr.AllRules)
{
if (rule.ApprovalState == false)
{
AddNotificationsRule(rule, hr.AllRules.IndexOf(rule), disapproved);
disapproved++;
}
else
{
AddHouseRule(rule, hr.AllRules.IndexOf(rule), approved);
approved++;
}
}
pnlNotifications.ResumeLayout();
pnlHouseRules.ResumeLayout();
}
}
}
if (_messages.AllMessages.Count != panelChat.Controls.Count)
{
for (int i = panelChat.Controls.Count; i < _messages.AllMessages.Count; i++)
{
AddMessages(_messages.AllMessages[i]);
}
panelChat.VerticalScroll.Value = panelChat.VerticalScroll.Maximum;
}
}
// Constructor to make the student form connect to the server
// Sees if the server sends "updated", if so: updates
public StudentForm(ServerConnection server, UserInfo student)
{
InitializeComponent();
ThreadStart threadStart = new ThreadStart(updateTemperature);
Thread t1 = new Thread(threadStart);
t1.Start();
Task.Run(() =>
{
udpClient.Client.Bind(new IPEndPoint(0, server.GetAvailableUdpPort()));
int attempts = 0;
string message = "";
while (true)
{
Thread.Sleep(100);
attempts++;
byte[] msg = new byte[udpClient.Client.Available];
if (msg.Length == 0 && attempts < 100)
{
continue;
}
else if (attempts >= 100)
{
}
else if (msg.Length == 0)
{
continue;
}
if (attempts < 100)
{
udpClient.Client.Receive(msg);
message = Encoding.Default.GetString(msg, 0, msg.Length);
}
if (message.Contains("Updated") || attempts >= 100)
{
student.StudentsInfo = server.GetUsersInfo(student.HouseNumber);
mandatoryRules = server.GetMandatoryRules(student.HouseNumber);
houseRules = server.GetHouseRules(student.HouseNumber);
complaints = server.GetComplaints(student.HouseNumber);
_messages = server.GetMessages(student.HouseNumber);
if (InvokeRequired)
{
Invoke((MethodInvoker) delegate
{
RulesUpdateTick();
UpdatesTick();
ScheduleUpdate();
});
}
else
{
RulesUpdateTick();
UpdatesTick();
ScheduleUpdate();
}
}
;
attempts = 0;
}
});
this.student = student;
this.server = server;
lblHello.Text = "Hello, " + this.student.Name;
mandatoryRules = server.GetMandatoryRules(student.HouseNumber);
houseRules = server.GetHouseRules(student.HouseNumber);
complaints = server.GetComplaints(student.HouseNumber);
_messages = server.GetMessages(student.HouseNumber);
ScheduleUpdate();
timerUpdate.Start();
RulesUpdateTick(false);
UpdatesTick();
}
public static void RegisterSecretHitler(this DiscordClient client, IConfiguration config)
{
Console.WriteLine("Registering 'Secret Hitler'...");
ReloadConfigs(Path.Combine(config["other"], "shitler.json"));
client.GetService <CommandService>().CreateCommand("rules")
.AddCheck((c, u, ch) => ch.Id == UInt64.Parse(config["FGO_SecretHitler"]))
.Description("Quick summary of the rules.")
.Do(async cea =>
{
var sb = new StringBuilder("How to play:\n")
.AppendLine("There are three roles: Liberal, Fascist, and Hitler.")
.AppendLine("Hitler does not know who his fellow Fascists are, but the Fascists know who Hitler is (except in 5 or 6 player games).")
.AppendLine("Liberals will always start off not knowing anything.")
.AppendLine("If 6 Fascist Policies are enacted, or Hitler is chosen as Chancellor in the late-game, the Fascists win.")
.AppendLine("If 5 Liberal Policies are enacted, or Hitler is successfully killed, the Liberals win.")
.AppendLine($"The following themes are available too: `{String.Join("`, `", configs.Select(c => c.Key))}`")
.AppendLine("For more details: https://dl.dropboxusercontent.com/u/502769/Secret_Hitler_Rules.pdf ")
.Append("Good luck, have fun.");
await cea.Channel.SendMessage(sb.ToString());
});
client.GetService <CommandService>().CreateCommand("opensh")
.AddCheck((c, u, ch) => u.Roles.Select(r => r.Id).Contains(UInt64.Parse(config["FGO_Admins"])) && ch.Id == UInt64.Parse(config["FGO_SecretHitler"]))
//.Parameter("type", ParameterType.Optional)
.Description("Open up a game of Secret ~~Angry Manjew~~ Hitler for people to join.")
.Do(async cea =>
{
if (!gameOpen)
{
rules = HouseRules.None;
players = new List <User>();
await cea.Channel.SendMessage("Opening up a round of Secret Hitler.");
}
});
client.GetService <CommandService>().CreateCommand("reload")
.AddCheck((c, u, ch) => u.Id == UInt64.Parse(config["Owner"]) && ch.Id == UInt64.Parse(config["FGO_SecretHitler"]))
.Hide()
.Do(cea => ReloadConfigs(Path.Combine(config["other"], "shitler.json")));
//client.GetService<CommandService>().CreateCommand("testsh")
// .AddCheck((c, u, ch) => u.Id == UInt64.Parse(config["Owner"]))
// .Hide()
// .Do(async cea =>
// {
// gameOpen = true;
// var joe = cea.User;
// var Game = new SecretHitler.SecretHitler(SecretHitlerConfig.Default, cea.Channel, new List<User> { joe, joe, joe, joe, joe });
// await Game.SetupGame();
// await Game.TestTurn(joe);
// await Game.TestNomination(joe, joe);
// game = Game;
// });
client.GetService <CommandService>().CreateCommand("players")
.AddCheck((c, u, ch) => ch.Id == UInt64.Parse(config["FGO_SecretHitler"]))
.Description("Display the currently joined players.")
.Do(async cea =>
{
await cea.Channel.SendMessage($"Current players are {String.Join(", ", players.Select(p => p.Name))}. ({players.Count})");
});
client.GetService <CommandService>().CreateCommand("join")
.AddCheck((c, u, ch) => ch.Id == UInt64.Parse(config["FGO_SecretHitler"]))
.Description("Join the game when it is open to play. At least 5 and at most 10 people can play. Using Voice is advised.")
.Do(async cea =>
{
if (!gameOpen)
{
if (players.Count == 10)
{
await cea.Channel.SendMessage($"The list is already full.");
return;
}
if (!players.Any(p => p.Id == cea.User.Id))
{
players.Add(cea.User);
await cea.Channel.SendMessage($"{cea.User.Name} joined the game.");
}
}
else
{
await cea.Channel.SendMessage($"Game is already in progress.");
}
});
client.GetService <CommandService>().CreateCommand("leave")
.AddCheck((c, u, ch) => ch.Id == UInt64.Parse(config["FGO_SecretHitler"]))
.Description("Leave a game if it has not been started yet.")
.Do(async cea =>
{
if (!gameOpen)
{
if (players.Any(p => p.Id == cea.User.Id))
{
players.Remove(cea.User);
await cea.Channel.SendMessage($"{cea.User.Name} left the game.");
}
}
});
client.GetService <CommandService>().CreateCommand("startsh")
.AddCheck((c, u, ch) => u.Roles.Select(r => r.Id).Contains(UInt64.Parse(config["FGO_Admins"])) && ch.Id == UInt64.Parse(config["FGO_SecretHitler"]))
.Parameter("type", ParameterType.Optional)
.Description("Start a game. `.opensh` has to be called before this and at least 5 people must join.")
.Do(async cea =>
{
if (!gameOpen && players != null)
{
if (players.Count >= 5 && players.Count <= 10)
{
gameOpen = true;
await cea.Channel.SendMessage($"Setting up game with {players.Count} players.");
var gameConfig = configs.SingleOrDefault(c => c.Key == cea.Args[0]) ?? SecretHitlerConfig.Default;
game = new SecretHitler.SecretHitler(gameConfig, cea.Channel, players);
await game.SetupGame();
}
}
});
client.GetService <CommandService>().CreateCommand("house")
.AddCheck((c, u, ch) => u.Roles.Select(r => r.Id).Contains(UInt64.Parse(config["FGO_Admins"])) && ch.Id == UInt64.Parse(config["FGO_SecretHitler"]))
.Parameter("rule", ParameterType.Unparsed)
.Description("Apply a House Rule.")
.Do(async cea =>
{
if (gameOpen)
{
await cea.Channel.SendMessage("Cannot change rules while game is in progress.");
return;
}
switch (cea.Args[0])
{
case "skipfirst":
rules |= HouseRules.SkipFirstElection;
await cea.Channel.SendMessage("House rule added.");
break;
default:
await cea.Channel.SendMessage("Unknown parameter.");
break;
}
});
client.GetService <CommandService>().CreateCommand("state")
.AddCheck((c, u, ch) => ch.Id == UInt64.Parse(config["FGO_SecretHitler"]))
.Description("Display the current state of the game.")
.Do(async cea =>
{
if (gameOpen)
{
await cea.Channel.SendMessage(game.GetGameState());
}
else
{
await cea.Channel.SendMessage("No game going on.");
}
});
client.GetService <CommandService>().CreateCommand("turn")
.AddCheck((c, u, ch) => u.Roles.Select(r => r.Id).Contains(UInt64.Parse(config["FGO_Admins"])) && ch.Id == UInt64.Parse(config["FGO_SecretHitler"]))
.Description("Advance to the next turn.")
.Do(async cea => await game.StartTurn());
client.GetService <CommandService>().CreateCommand("endsh")
.AddCheck((c, u, ch) => u.Roles.Select(r => r.Id).Contains(UInt64.Parse(config["FGO_Admins"])) && ch.Id == UInt64.Parse(config["FGO_SecretHitler"]))
.Description("End the game early.")
.Do(async cea => {
await game.EndGame();
gameOpen = true;
});
client.GetService <CommandService>().CreateCommand("cancel")
.AddCheck((c, u, ch) => u.Roles.Select(r => r.Id).Contains(UInt64.Parse(config["FGO_Admins"])) && ch.Id == UInt64.Parse(config["FGO_SecretHitler"]))
.Hide()
.Do(async cea =>
{
gameOpen = false;
await cea.Channel.SendMessage("Game canceled.");
});
}
//Checks if needed files/directories exist
//Creates new files if it is needed
private void CheckExistedFiles(int houseNumber)
{
//Checks if directory for this house exists
if (!Directory.Exists(@$ "data/house-{houseNumber}"))
{
//Creates new directory
Directory.CreateDirectory(@$ "data/house-{houseNumber}");
}
//Checks if file for house rules exists
if (!File.Exists(@$ "data/house-{houseNumber}/house-rules.json"))
{
//Creates a new object with zero rules
HouseRules houseRules = new HouseRules
{
HouseNumber = houseNumber,
AllRules = new List <HouseRule>()
};
//Saves new file
File.WriteAllText(@$ "data/house-{houseNumber}/house-rules.json",
JsonConvert.SerializeObject(houseRules, Formatting.Indented));
}
//Checks if file for mandatory rules exists
if (!File.Exists(@$ "data/house-{houseNumber}/mandatory-rules.json"))
{
//Creates a new object with zero rules
MandatoryRules houseRules = new MandatoryRules
{
HouseNumber = houseNumber,
AllRules = new List <MandatoryRule>()
};
//Saves new file
File.WriteAllText(@$ "data/house-{houseNumber}/mandatory-rules.json",
JsonConvert.SerializeObject(houseRules, Formatting.Indented));
}
//Checks if file for users exists
if (!File.Exists(@$ "data/house-{houseNumber}/students.json"))
{
//Creates a new object with zero users
Users users = new Users
{
TotalStudentNumber = 0,
AllUsers = new List <ServerUser>()
};
//Saves new file
File.WriteAllText(@$ "data/house-{houseNumber}/students.json",
JsonConvert.SerializeObject(users, Formatting.Indented));
}
//Checks if file for complaints rules exists
if (!File.Exists(@$ "data/house-{houseNumber}/complaints.json"))
{
//Creates a new object with zero complaints
Complaints complaints = new Complaints
{
HouseNumber = houseNumber,
AllComplaints = new List <Complaint>()
};
//Saves new file
File.WriteAllText(@$ "data/house-{houseNumber}/complaints.json",
JsonConvert.SerializeObject(complaints, Formatting.Indented));
}
if (!File.Exists(@$ "data/house-{houseNumber}/messages.json"))
{
//Creates a new object with zero complaints
ChatHistory messages = new ChatHistory
{
HouseNumber = houseNumber,
AllMessages = new List <ChatMessage>()
};
//Saves new file
File.WriteAllText(@$ "data/house-{houseNumber}/messages.json",
JsonConvert.SerializeObject(messages, Formatting.Indented));
}
}
//Handles received packages based on their types
private void HandleDataQuery(TcpClient client, ServerPackage package)
{
//Based on the package type returns needed information
switch (package.Type)
{
case PackageType.USER_CHECK:
{
CheckUdp(package.UdpServerPort);
UserCheck userCheck = JsonConvert.DeserializeObject <UserCheck>(package.Message);
ServerUser user = CheckUserInfo(client, userCheck);
//Checks if user with given credentials exists
if (user == null)
{
//Sends "invalid data" error if user doesn't exist
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.INVALID_DATA, "", -1)));
}
else
{
Users users = JsonConvert.DeserializeObject <Users>(File.ReadAllText(@$ "data/house-{userCheck.HouseNumber}/students.json"));
Dictionary <int, string> usersInfo = new Dictionary <int, string>();
//Adds all student's Name and ID in a dictionary
foreach (var u in users.AllUsers)
{
usersInfo.Add(u.ID, u.Name);
}
//Generates new object with all needed info as a responce
UserInfo userInfo = new UserInfo()
{
Type = user.Type,
ID = user.ID,
Name = user.Name,
LastName = user.LastName,
HouseNumber = user.HouseNumber,
Room = user.Room,
TotalStudentNumber = users.TotalStudentNumber,
StudentsInfo = usersInfo
};
string json = JsonConvert.SerializeObject(userInfo);
//Sends responce
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.USER_INFO, json, -1)));
}
break;
}
case PackageType.GET_ALL_USERS:
{
CheckUdp(package.UdpServerPort);
Users users = JsonConvert.DeserializeObject <Users>(File.ReadAllText(@$ "data/house-{package.Message}/students.json"));
Dictionary <int, string> usersInfo = new Dictionary <int, string>();
//Adds all student's Name and ID in a dictionary
foreach (var u in users.AllUsers)
{
usersInfo.Add(u.ID, u.Name);
}
string json = JsonConvert.SerializeObject(usersInfo);
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.ALL_USERS, json, -1)));
break;
}
case PackageType.GET_HOUSE_RULES:
{
//Checks if needed files/directories exist
CheckExistedFiles(Convert.ToInt32(package.Message));
CheckUdp(package.UdpServerPort);
//Sends responce
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.HOUSE_RULES,
File.ReadAllText(@$ "data/house-{package.Message}/house-rules.json"), -1)));
break;
}
case PackageType.UPDATE_HOUSE_RULES:
{
HouseRules houseRules = JsonConvert.DeserializeObject <HouseRules>(package.Message);
//Checks if needed files/directories exist
CheckExistedFiles(Convert.ToInt32(houseRules.HouseNumber));
CheckUdp(package.UdpServerPort);
//Update file
File.WriteAllText(@$ "data/house-{houseRules.HouseNumber}/house-rules.json", package.Message);
SendUpdated(package.UdpServerPort);
//Sends responce
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.RECEIVED, "", -1)));
break;
}
case PackageType.GET_MANDATORY_RULES:
{
//Checks if needed files/directories exist
CheckExistedFiles(Convert.ToInt32(package.Message));
CheckUdp(package.UdpServerPort);
//Sends responce
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.MANDATORY_RULES,
File.ReadAllText(@$ "data/house-{package.Message}/mandatory-rules.json"), -1)));
break;
}
case PackageType.UPDATE_MANDATORY_RULES:
{
MandatoryRules mandatoryRules = JsonConvert.DeserializeObject <MandatoryRules>(package.Message);
//Checks if needed files/directories exist
CheckExistedFiles(Convert.ToInt32(mandatoryRules.HouseNumber));
CheckUdp(package.UdpServerPort);
SendUpdated(package.UdpServerPort);
//Update file
File.WriteAllText(@$ "data/house-{mandatoryRules.HouseNumber}/mandatory-rules.json", package.Message);
//Sends responce
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.RECEIVED, "", -1)));
break;
}
case PackageType.GET_COMPLAINTS:
{
//Checks if needed files/directories exist
CheckExistedFiles(Convert.ToInt32(package.Message));
CheckUdp(package.UdpServerPort);
//Sends responce
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.COMPLAINTS,
File.ReadAllText(@$ "data/house-{package.Message}/complaints.json"), -1)));
break;
}
case PackageType.UPDATE_COMPLAINTS:
{
MandatoryRules mandatoryRules = JsonConvert.DeserializeObject <MandatoryRules>(package.Message);
//Checks if needed files/directories
CheckExistedFiles(Convert.ToInt32(mandatoryRules.HouseNumber));
CheckUdp(package.UdpServerPort);
SendUpdated(package.UdpServerPort);
//Update file
File.WriteAllText(@$ "data/house-{mandatoryRules.HouseNumber}/complaints.json", package.Message);
//Sends responce
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.RECEIVED, "", -1)));
break;
}
case PackageType.GET_MESSAGES:
{
//Checks if needed files/directories exist
CheckExistedFiles(Convert.ToInt32(package.Message));
CheckUdp(package.UdpServerPort);
//Sends responce
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.MESSAGES,
File.ReadAllText(@$ "data/house-{package.Message}/messages.json"), -1)));
break;
}
case PackageType.UPDATE_MESSAGES:
{
ChatHistory chathistory = JsonConvert.DeserializeObject <ChatHistory>(package.Message);
//Checks if needed files/directories
CheckExistedFiles(Convert.ToInt32(chathistory.HouseNumber));
CheckUdp(package.UdpServerPort);
//Update file
File.WriteAllText(@$ "data/house-{chathistory.HouseNumber}/messages.json", package.Message);
SendUpdated(package.UdpServerPort);
//Sends responce
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.RECEIVED, "", -1)));
break;
}
case PackageType.UPDATE_PASSWORD:
{
CheckUdp(package.UdpServerPort);
PasswordChange passwordChange = JsonConvert.DeserializeObject <PasswordChange>(package.Message);
Users users = JsonConvert.DeserializeObject <Users>(File.ReadAllText(@$ "data/house-{passwordChange.HouseNumber}/students.json"));
//Searches for login of the user based on his ID
string login = users.AllUsers.Find(x => x.ID == passwordChange.ID).Login;
UserCheck userCheck = new UserCheck(login, passwordChange.CurrentPassword, passwordChange.HouseNumber);
ServerUser user = CheckUserInfo(client, userCheck);
//Checks if user with given credentials exists
if (user == null)
{
//Sends "invalid data" error if user doesn't exist
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.INVALID_DATA, "", -1)));
}
else
{
foreach (var u in users.AllUsers)
{
//Searches needed user and changes his password
if (u.ID == user.ID)
{
u.Password = passwordChange.NewPassword;
break;
}
}
string json = JsonConvert.SerializeObject(users, Formatting.Indented);
File.WriteAllText(@$ "data/house-{userCheck.HouseNumber}/students.json", json);
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.PASSWORD_CHANGED, "", -1)));
}
break;
}
case PackageType.CREATE_NEW_USER:
{
CheckUdp(package.UdpServerPort);
ServerUser newUser = JsonConvert.DeserializeObject <ServerUser>(package.Message);
Users users = JsonConvert.DeserializeObject <Users>(File.ReadAllText(@$ "data/house-{newUser.HouseNumber}/students.json"));
int lastId = users.AllUsers.Max(x => x.ID);
lastId++;
newUser.ID = lastId;
//If there are no users with the same login - proceed
if (users.AllUsers.Any(x => x.Login == newUser.Login))
{
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.USER_EXISTS, "", -1)));
}
else
{
users.AllUsers.Add(newUser);
users.TotalStudentNumber++;
string json = JsonConvert.SerializeObject(users, Formatting.Indented);
File.WriteAllText(@$ "data/house-{newUser.HouseNumber}/students.json", json);
HouseRules houseRules = JsonConvert.DeserializeObject <HouseRules>(
File.ReadAllText(@$ "data/house-{newUser.HouseNumber}/house-rules.json"));
foreach (var rule in houseRules.AllRules)
{
if (rule.ApprovalState)
{
rule.StudentsApproval.Add(newUser.ID, true);
}
else
{
rule.StudentsApproval.Add(newUser.ID, false);
}
rule.OrderOfStudents.Add(newUser.ID);
}
json = JsonConvert.SerializeObject(houseRules, Formatting.Indented);
File.WriteAllText(@$ "data/house-{newUser.HouseNumber}/house-rules.json", json);
SendMessage(package.Type, client, JsonConvert.SerializeObject(new ServerPackage(PackageType.USER_CREATED, "", -1)));
}
SendUpdated(package.UdpServerPort);
break;
}
}
}
