public ClientBase(MNetworkClient NetworkClient, ServerBase Server)
{
this.NetworkClient = NetworkClient;
this._ServerBase = Server;
this._ServerBase.AddConnection(NetworkClient);
}
private void WebRequestDirSaver(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "requests.add"))
{
return;
}
var WebRequestDirItem = Package.Unpacking <WebRequestDir>(ClientResponse.DataBytes);
using (var db = new DatabaseContext())
{
db.Attach(WebRequestDirItem);
db.SaveChanges();
Sender.Broadcast("WebRequestDir.Save.Confirm", WebRequestDirItem, ClientResponse.WindowUid);
WebRequestItem WebRequestItem =
db.WebRequestItems.FirstOrDefault(x => x.Id == WebRequestDirItem.WebRequestItemId);
MBinding_WebRequest MBinding = new MBinding_WebRequest();
MBinding.Item = WebRequestItem;
MBinding.Params = db.WebRequestParamsItems.Where(x => x.WebRequestItemId == WebRequestItem.Id).ToArray();
MBinding.Directory = WebRequestDirItem;
Sender.Broadcast("WebRequestItem.MBinding_WebRequest.Add", MBinding);
}
}
private void UsersGetAll(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "users"))
{
return;
}
try
{
using (var db = new DatabaseContext())
{
var DbUsers = db.Users.ToArray();
var WUsers = DbConvertToWpf.ConvertUser(DbUsers);
if (AccessController.IsPrivilege(NetworkClient, "users"))
{
Sender.Send(NetworkClient, "Users.GetAll.Confirm", WUsers);
}
}
}
catch (DbException ex)
{
Debug.LogError("Возникло исключение при получении списка пользователей. Код ошибки:\n" + ex);
Sender.Send(NetworkClient, "Users.GetAll.Error");
}
}
private void AddProject(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "projects.add"))
{
return;
}
try
{
using (var db = new DatabaseContext())
{
var MPorject = Package.Unpacking <Project>(ClientResponse.DataBytes);
MPorject.UserId = Users.GetUserById(NetworkClient.Id).Id;
db.Projects.Attach(MPorject);
db.SaveChanges();
if (AccessController.IsPrivilege(NetworkClient, "edit_project"))
{
Sender.Broadcast("Project.Add.Confirm", MPorject);
}
}
}
catch (DbException ex)
{
}
}
private void AddHistoryItem(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "requests.history.add"))
{
return;
}
try
{
var WebRequestHistoryItem = Package.Unpacking <WebRequestHistory>(ClientResponse.DataBytes);
using (var db = new DatabaseContext())
{
if (WebRequestHistoryItem != null)
{
db.WebRequestsHistory.Add(WebRequestHistoryItem);
db.SaveChanges();
Sender.Send(NetworkClient, "RequestsHistory.Add.Confirm", WebRequestHistoryItem);
}
}
}
catch (DbException ex)
{
Debug.LogError("Возникло исключение при добавлении объекта истории в базу данных. Код ошибки: " + ex);
}
}
private void GetTeamProjects(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "projects"))
{
return;
}
try
{
using (var db = new DatabaseContext())
{
var TeamGroups = db.TeamGroups.ToArray();
Debug.Log($"Получен список команд из базы данных в количестве {TeamGroups.Length} записей.", ConsoleColor.Magenta);
var MProject = Package.Unpacking <Project>(ClientResponse.DataBytes);
var DbProjects = db.TeamProjects.Where(t => t.ProjectId == MProject.Id).ToArray();
Debug.Log($"Получен список проектов и команд из базы данных в количестве {DbProjects.Length} записей.", ConsoleColor.Magenta);
Sender.Send(NetworkClient, "TeamProject.Get",
DbConvertToWpf.ConvertTeamProjectCompilation(TeamGroups, DbProjects), ClientResponse.WindowUid);
}
}
catch (DbException ex)
{
Debug.LogError("Возникла ошибка при получении списка проектов и команд из базы данных! Код ошибки:\n" + ex);
Sender.Send(NetworkClient, "TeamProject.Get.Error");
}
}
private void AccessGetAll(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "teams.access"))
{
return;
}
try
{
int TeamId = Package.Unpacking <int>(ClientResponse.DataBytes);
using (var db = new DatabaseContext())
{
var DbTeamPrivileges = db.TeamPrivileges.Where(x => x.TeamGroupId == TeamId).ToArray();
Debug.Log($"Получен список прав доступа в количестве {DbTeamPrivileges.Length} записей.", ConsoleColor.Magenta);
Sender.Send(NetworkClient, "Team.Access.GetAll.Confirm",
DbTeamPrivileges, ClientResponse.WindowUid);
}
}
catch (DbException ex)
{
Debug.LogError("Возникло исключение при получении списка прав доступа. Код ошибки:\n" + ex);
Sender.Send(NetworkClient, "Team.Access.GetAll.Error");
}
}
private void HistoryGetAll(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "requests.history"))
{
return;
}
try
{
var ProjectId = Package.Unpacking <int>(ClientResponse.DataBytes);
using (var db = new DatabaseContext())
{
WebRequestHistory[] DbHistory = db.WebRequestsHistory.Where(x => x.ProjectId == ProjectId).ToArray();
if (DbHistory.Length != 0)
{
Sender.Send(NetworkClient, "RequestsHistory.GetAll.Confirm", DbHistory);
}
}
}
catch (DbException ex)
{
Debug.LogError("Возникло исключение при получении истории запросов с сервера. Код ошибки: " + ex);
}
}
private void WebRequestDirHistoryEdit(MResponse ClientResponse, MNetworkClient NetworkClient)
{
var RequestHistory = Package.Unpacking <WebRequestHistory>(ClientResponse.DataBytes);
using (var db = new DatabaseContext())
{
ModelRequestDirectory RequestDir = new ModelRequestDirectory();
RequestDir.RequestMethod = RequestHistory.Method;
RequestDir.RequestTitle = RequestHistory.Title;
RequestDir.WebRequestId = RequestHistory.WebRequestItemId;
WebRequestDir WebDir = db.WebRequestDirs.FirstOrDefault(x => x.WebRequestItemId == RequestHistory.WebRequestItemId);
RequestDir.Id = WebDir.Id;
RequestDir.Title = WebDir.Title;
Debug.Log($"\r\nId - {RequestDir.Id}\n" +
$"RequestMethod - {RequestDir.RequestMethod}\n" +
$"RequestTitle - {RequestDir.RequestTitle}\n" +
$"Title - {RequestDir.Title}\n" +
$"WebRequestId - {RequestDir.WebRequestId}\r\n");
Sender.Broadcast("WebRequestDir.History.Edit.Confirm",
RequestDir, ClientResponse.WindowUid);
}
}
private void ChatMessagesNew(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "projects.chat"))
{
return;
}
try
{
var PreMessage = Package.Unpacking <Chat>(ClientResponse.DataBytes);
using (var db = new DatabaseContext())
{
PreMessage.UserId = Users.GetUserById(NetworkClient.Id).Id;
PreMessage.Date = DateTime.Now;
db.Chats.Add(PreMessage);
db.SaveChanges();
Sender.Broadcast("Chat.Messages.New.Confirm", GetModelMessage(db, PreMessage));
}
}
catch (DbException ex)
{
Debug.LogError("Возникло исключение при добавлении нового сообщения. Код ошибки:\n" + ex);
Sender.Send(NetworkClient, "Chat.Messages.New.Error");
}
}
public static bool IsOwner(MNetworkClient NetworkClient)
{
try
{
using (var db = new DatabaseContext())
{
var User = Users.GetUserById(NetworkClient.Id);
Debug.Log($"Проверка на полный доступ пользователя [{User.Id}] - {User.Login}", ConsoleColor.Gray);
if (User.Id == 1)
{
return(true);
}
var DbUserPrivileges = db.UserPrivileges.Where(x => x.UserId == User.Id).ToArray();
foreach (var DbUserPrivilege in DbUserPrivileges)
{
if (DbUserPrivilege.Privilege == "admin")
{
return(true);
}
}
}
}
catch { }
Debug.LogWarning($"Ошибка доступа! Пользователь не имеет необходимых привилегий!");
return(false);
}
private void ChatMessagesGetAll(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "projects.chat"))
{
return;
}
try
{
int ProjectId = Package.Unpacking <int>(ClientResponse.DataBytes);
using (var db = new DatabaseContext())
{
Chat[] ChatMessages = db.Chats.Where(x => x.ProjectId == ProjectId).ToArray();
if (ChatMessages.Length != 0)
{
List <ModelChatMessage> mChatMessages = new List <ModelChatMessage>();
foreach (var Message in ChatMessages)
{
mChatMessages.Add(GetModelMessage(db, Message));
}
Sender.Send(NetworkClient, "Chat.Messages.GetAll.Confirm", mChatMessages.ToArray());
}
}
}
catch (DbException ex)
{
Debug.LogError("Возникло исключение при получении списка сообщений. Код ошибки:\n" + ex);
Sender.Send(NetworkClient, "Chat.Messages.GetAll.Error");
}
}
private void GetTeamUsers(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "teams"))
{
return;
}
try
{
using (var db = new DatabaseContext())
{
var UsersDb = db.Users.ToArray();
Debug.Log($"Получен список пользователей из базы данных в количестве {UsersDb.Length} записей.", ConsoleColor.Magenta);
var TGroup = Package.Unpacking <TeamGroup>(ClientResponse.DataBytes);
var TeamUsersDb = db.TeamUsers.Where(t => t.TeamGroupId == TGroup.Id).ToArray();
Debug.Log($"Получен список команд и пользователей из базы данных в количестве {TeamUsersDb.Length} записей.", ConsoleColor.Magenta);
Sender.Send(NetworkClient, "TeamUser.Get",
DbConvertToWpf.ConvertTeamUserCompilation(UsersDb, TeamUsersDb), ClientResponse.WindowUid);
}
}
catch (DbException ex)
{
Debug.LogError("Возникла ошибка при получении списка пользователей из базы данных! Код ошибки:\n" + ex);
Sender.Send(NetworkClient, "TeamUser.Get.Error");
}
}
private void WebRequestBindingGet(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "requests"))
{
return;
}
int ProjectId = Package.Unpacking <int>(ClientResponse.DataBytes);
using (var db = new DatabaseContext())
{
List <MBinding_WebRequest> MB_WebRequests = new List <MBinding_WebRequest>();
WebRequestItem[] WebRequestItems =
db.WebRequestItems.Where(x => x.ProjectId == ProjectId).ToArray();
foreach (var RequestItem in WebRequestItems)
{
MBinding_WebRequest ListItem = new MBinding_WebRequest();
ListItem.Item = RequestItem;
ListItem.Params = db.WebRequestParamsItems.Where(x => x.WebRequestItemId == RequestItem.Id).ToArray();
ListItem.Directory = db.WebRequestDirs.FirstOrDefault(x => x.WebRequestItemId == RequestItem.Id);
MB_WebRequests.Add(ListItem);
}
Sender.Send(NetworkClient, "WebRequestItem.MBinding_WebRequest.Get",
MB_WebRequests.ToArray(), ClientResponse.WindowUid);
}
}
private void WebRequestParamsUpdate(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "requests.edit"))
{
return;
}
try
{
var RequestParamsItems = Package.Unpacking <MBinding_WebRequestSaver>(ClientResponse.DataBytes);
using (var db = new DatabaseContext())
{
var DbRequestParamsItems = new List <WebRequestParamsItem>();
foreach (var RequestParamsItem in RequestParamsItems.Params)
{
WebRequestParamsItem DbRequestParam = db.WebRequestParamsItems.FirstOrDefault
(x => x.Id == RequestParamsItem.Id);
if (DbRequestParam != null)
{
DbRequestParam.Key = RequestParamsItem.Key;
DbRequestParam.Value = RequestParamsItem.Value;
DbRequestParam.Description = RequestParamsItem.Description;
db.SaveChanges();
DbRequestParamsItems.Add(DbRequestParam);
}
else
{
//if (db.WebRequestParamsItems.FirstOrDefault(x => x.Key == RequestParamsItem.Key) == null)
//{
DbRequestParam = RequestParamsItem;
DbRequestParam.Key = (DbRequestParam.Key != null) ? DbRequestParam.Key : "";
DbRequestParam.Value = (DbRequestParam.Value != null) ? DbRequestParam.Value : "";
DbRequestParam.Description = (DbRequestParam.Description != null) ? DbRequestParam.Description : "";
DbRequestParam.WebRequestItemId = RequestParamsItems.Item.Id;
if (DbRequestParam.Key.Trim() != string.Empty || DbRequestParam.Value.Trim() != string.Empty)
{
db.WebRequestParamsItems.Add(DbRequestParam);
db.SaveChanges();
DbRequestParamsItems.Add(DbRequestParam);
}
//}
}
}
if (DbRequestParamsItems.Count != 0)
{
Sender.Broadcast("WebRequestParamsItem.Update.Confirm", DbRequestParamsItems.ToArray());
}
}
}
catch (DbException ex)
{
Sender.Send(NetworkClient, "WebRequestParamsItem.Update.Error");
}
}
public static void SendOmit(MNetworkClient NetworkClient, string KeyNetwork, object DataObject = null, int WindowUid = -1)
{
foreach (var UserNetwork in NetworkClients)
{
if (NetworkClient.Id != UserNetwork.Id)
{
Send(UserNetwork, KeyNetwork, DataObject, WindowUid);
}
}
}
protected internal void RemoveConnection(string id)
{
MNetworkClient NetworkClient = NetworkBase.NetworkClients.FirstOrDefault(c => c.Id == id);
if (NetworkClient != null)
{
NetworkBase.NetworkClients.Remove(NetworkClient);
}
Debug.Log($"Клиент отключён: [{NetworkClient.Id}] {NetworkClient.Ip}:{NetworkClient.Port}");
}
public static bool IsPrivilegeTeam(MNetworkClient NetworkClient, string PrivilegeKey, int TeamGroupId = 0)
{
if (IsOwner(NetworkClient))
{
return(true);
}
try
{
using (var db = new DatabaseContext())
{
var User = Users.GetUserById(NetworkClient.Id);
Debug.Log($"Проверка прав доступа пользователя [{User.Id}] - {User.Login} в командах", ConsoleColor.Gray);
TeamPrivilege[] DbUserPrivileges;
if (TeamGroupId == 0)
{
DbUserPrivileges = db.TeamPrivileges.ToArray();
}
else
{
DbUserPrivileges = db.TeamPrivileges.Where(x => x.TeamGroupId == TeamGroupId).ToArray();
}
foreach (var DbUserPrivilege in DbUserPrivileges)
{
if (DbUserPrivilege.Privilege == PrivilegeKey || DbUserPrivilege.Privilege == "admin")
{
Debug.Log($"Привелигия {PrivilegeKey} найдена! Проверка на наличие пользователя в команде...");
var DbTeamGroup = db.TeamUsers.FirstOrDefault(x => x.TeamGroupId == DbUserPrivilege.TeamGroupId &&
x.UserId == User.Id);
if (DbTeamGroup != null)
{
Debug.Log($"> Привилегия [{PrivilegeKey}] доступна", ConsoleColor.Gray);
return(true);
}
}
}
Debug.LogWarning($"> Привилегия [{PrivilegeKey}] не доступна в командах");
}
}
catch { }
Debug.LogWarning($"Ошибка доступа! Пользователь не состоит в команде с необходимыми привилегиями!");
return(false);
}
public static void RemoveById(string NetworkId)
{
if (ActiveUsersMoreInfo.Exists(x => x.NetworkClient.Id == NetworkId))
{
MNetworkClient NetworkClient = ActiveUsersMoreInfo.Find(x => x.NetworkClient.Id == NetworkId).NetworkClient;
ActiveUsersMoreInfo.RemoveAll(x => x.NetworkClient == NetworkClient);
ActiveUsers.RemoveAll(x => x.NetworkId == NetworkId);
Debug.Log("Пользователь удалён из системного списка");
Sender.Broadcast("Users.Remove", NetworkId);
}
}
public static void Send(MNetworkClient NetworkClient, string KeyNetwork, object DataObject = null, int WindowUid = -1)
{
try
{
Debug.Log("Подготовка запроса для отправки клиенту. Информация о запросе: \n" +
$"KeyNetwork - {KeyNetwork}, WindowUid - {WindowUid}\n" +
$"Информация о пользователе: [{NetworkClient.Id}] {NetworkClient.Ip}:{NetworkClient.Port}");
if (!NetworkClient.ClientNetwork.Connected)
{
Debug.LogWarning("Не удалось проверить соединение с клиентом, запрос отклонён!");
return;
}
byte[] DataBytes;
if (DataObject != null && DataObject.GetType().Name == "Byte[]")
{
DataBytes = (byte[])DataObject;
}
else
{
DataBytes = Package.Packaging((DataObject == null) ? "" : DataObject);
}
var Receiver = new MResponse();
Receiver.WindowUid = WindowUid;
Receiver.KeyNetwork = KeyNetwork;
Receiver.DataBytes = DataBytes;
byte[] WriteDataBytes = Package.Packaging(Receiver);
try
{
NetworkClient.ClientNetwork.Send(WriteDataBytes);
Debug.Log("Данные успешно отправлены клиенту.");
}
catch (SocketException ex)
{
Debug.LogError("Возникла ошибка при попытке отправить запрос клиенту. " +
"Код ошибки:\n" + ex);
}
}
catch (Exception ex)
{
Debug.LogError("Возникла ошибка при создании экземпляра транспортировки. " +
"Код ошибки:\n" + ex);
}
}
public static void Add(MNetworkClient NetworkClient, MUserNetwork NetworkUser)
{
ActiveUsersMoreInfo.Add(new UserStructure
{
NetworkClient = NetworkClient,
NetworkUser = NetworkUser
});
ActiveUsers.Add(NetworkUser);
Debug.Log("Пользователь добавлен в системный список");
Sender.Send(NetworkClient, "Users.Update", ActiveUsers.ToArray());
Sender.SendOmit(NetworkClient, "Users.Add", NetworkUser);
}
private void WebRequestParamsGet(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "requests"))
{
return;
}
int ItemId = Package.Unpacking <int>(ClientResponse.DataBytes);
using (var db = new DatabaseContext())
{
WebRequestParamsItem[] RequestParams = db.WebRequestParamsItems.ToArray();
Sender.Send(NetworkClient, "WebRequestParamsItem.Get.Confirm", RequestParams, ClientResponse.WindowUid);
}
}
private void UpdateProject(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "projects.edit"))
{
return;
}
try
{
using (var db = new DatabaseContext())
{
var MProject = Package.Unpacking <Project>(ClientResponse.DataBytes);
Project DbProject = db.Projects.Where(p => p.Id == MProject.Id).FirstOrDefault();
Project DbProjectCache = new Project
{
Id = DbProject.Id,
Uid = DbProject.Uid,
Title = DbProject.Title,
UserId = DbProject.UserId
};
DbProject.Uid = MProject.Uid;
DbProject.Title = MProject.Title;
db.SaveChanges();
Debug.Log($"Информация о команде обновлена:\n" +
$"Id - {DbProjectCache.Id} > {MProject.Id}\n" +
$"TeamUid - {DbProjectCache.Uid} > {MProject.Uid}\n" +
$"Title - {DbProjectCache.Title} > {MProject.Title}\n" +
$"UserId - {DbProjectCache.UserId} > {MProject.UserId}", ConsoleColor.Magenta);
if (AccessController.IsPrivilege(NetworkClient, "edit_project"))
{
Sender.Broadcast("Project.Update.Confirm", DbProject, ClientResponse.WindowUid);
}
}
}
catch (DbUpdateException ex)
{
Debug.LogError("Возникла ошибка при обновлении команды в базе данных! Код ошибки:\n" + ex);
Sender.Send(NetworkClient, "Project.Update.Error");
}
}
private void RegisterUser(MResponse ClientResponse, MNetworkClient NetworkClient)
{
try
{
using (var db = new DatabaseContext())
{
var user = Package.Unpacking <Compo_Shared_Data.Models.User>(ClientResponse.DataBytes);
if (db.Users.Where(u => u.Email == user.Email).FirstOrDefault() == null &&
db.Users.Where(u => u.Login == user.Login).FirstOrDefault() == null)
{
user.Password = Crypter.Blowfish.Crypt(user.Password);
db.Users.Add(user);
db.SaveChanges();
Debug.Log("В базу данных добавлен новый пользователь", ConsoleColor.Magenta);
Sender.Send(NetworkClient, "User.Register.Confirm", default, 2);
private void GetAllTeamGroups(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "teams"))
{
return;
}
try
{
using (var db = new DatabaseContext())
{
List <TeamGroup> TeamGroupsDb;
if (AccessController.IsOwner(NetworkClient))
{
TeamGroupsDb = db.TeamGroups.ToList();
}
else
{
int UserId = Users.GetUserById(NetworkClient.Id).Id;
TeamGroupsDb = db.TeamGroups.Where(x => x.UserId == UserId).ToList();
TeamUser[] TeamUsersDb = db.TeamUsers.Where(x => x.UserId == UserId).ToArray();
foreach (var TeamUserDb in TeamUsersDb)
{
if (!TeamGroupsDb.Exists(x => x.Id == TeamUserDb.TeamGroupId))
{
TeamGroupsDb.Add(db.TeamGroups.FirstOrDefault(x => x.Id == TeamUserDb.TeamGroupId));
}
}
}
Debug.Log($"Получен список команд из базы данных в количестве {TeamGroupsDb.Count} записей.", ConsoleColor.Magenta);
Sender.Send(NetworkClient, "TeamGroup.GetAll", TeamGroupsDb.ToArray(), ClientResponse.WindowUid);
}
}
catch (Exception ex)
{
Debug.LogError("Возникла ошибка при получении списка команд из базы данных! Код ошибки:\n" + ex);
Sender.Send(NetworkClient, "TeamGroup.GetAll.Error");
}
}
private void UsersUpdate(MResponse ClientResponse, MNetworkClient NetworkClient)
{
try
{
var User = Package.Unpacking <User>(ClientResponse.DataBytes);
using (var db = new DatabaseContext())
{
MUserNetwork NetUser = Users.GetUserById(NetworkClient.Id);
if (NetUser.Id != User.Id)
{
if (User.Id == 1 && NetUser.Id != 1)
{
return;
}
if (!AccessController.IsPrivilege(NetworkClient, "users.edit"))
{
return;
}
}
var DbUser = db.Users.FirstOrDefault(x => x.Id == User.Id);
DbUser.Login = User.Login;
DbUser.Email = User.Email;
DbUser.Name = User.Name;
DbUser.Surname = User.Surname;
DbUser.Patronymic = User.Patronymic;
if (User.Password != null && User.Password.Length != 0 && User.Password.Trim() != string.Empty)
{
DbUser.Password = Crypter.Blowfish.Crypt(User.Password);
}
db.SaveChanges();
Sender.Send(NetworkClient, "Users.Update.Confirm", User);
}
}
catch (DbException ex)
{
Debug.LogError("Возникло исключение при обновлении данных пользователя. Код ошибки:\n" + ex);
Sender.Send(NetworkClient, "Users.Update.Error");
}
}
private void WebRequestDirDelete(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "requests.delete"))
{
return;
}
var WebRequestId = Package.Unpacking <int>(ClientResponse.DataBytes);
using (var db = new DatabaseContext())
{
var RequestItem = db.WebRequestItems.FirstOrDefault(x => x.Id == WebRequestId);
db.WebRequestItems.Remove(RequestItem);
db.SaveChanges();
Sender.Broadcast("WebRequestDir.Delete.Confirm", RequestItem, ClientResponse.WindowUid);
}
}
private void WebRequestLinkUpdate(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "requests.edit"))
{
return;
}
using (var db = new DatabaseContext())
{
var RequestItem = Package.Unpacking <WebRequestItem>(ClientResponse.DataBytes);
WebRequestItem DbRequestItem = db.WebRequestItems.FirstOrDefault(x => x.Id == RequestItem.Id);
DbRequestItem.Link = RequestItem.Link;
db.SaveChanges();
Sender.SendOmit(NetworkClient, "WebRequestItem.Update.Link.Confirm", DbRequestItem, ClientResponse.WindowUid);
}
}
private void UpdateTeamGroup(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "teams.edit"))
{
return;
}
try
{
using (var db = new DatabaseContext())
{
var MTeamGroup = Package.Unpacking <TeamGroup>(ClientResponse.DataBytes);
var DbTeamGroupCache = new TeamGroup
{
Id = MTeamGroup.Id,
Uid = MTeamGroup.Uid,
Title = MTeamGroup.Title,
UserId = MTeamGroup.UserId
};
var DbTeamGroup = db.TeamGroups.FirstOrDefault(t => t.Id == MTeamGroup.Id);
DbTeamGroup.Title = MTeamGroup.Title;
DbTeamGroup.Uid = MTeamGroup.Uid;
db.SaveChanges();
Debug.Log($"Информация о команде обновлена:\n" +
$"Id - {DbTeamGroupCache.Id} > {DbTeamGroup.Id}\n" +
$"TeamUid - {DbTeamGroupCache.Uid} > {DbTeamGroup.Uid}\n" +
$"Title - {DbTeamGroupCache.Title} > {DbTeamGroup.Title}\n" +
$"UserId - {DbTeamGroupCache.UserId} > {DbTeamGroup.UserId}", ConsoleColor.Magenta);
Sender.Broadcast("TeamGroup.Update.Confirm", DbTeamGroup, ClientResponse.WindowUid);
}
}
catch (DbUpdateException ex)
{
Debug.LogError("Возникла ошибка при обновлении команды в базе данных! Код ошибки:\n" + ex);
Sender.Send(NetworkClient, "TeamGroup.Update.Error");
}
}
private void AddTeamGroup(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "teams.add"))
{
return;
}
try
{
using (var db = new DatabaseContext())
{
var MTeamGroup = Package.Unpacking <TeamGroup>(ClientResponse.DataBytes);
var DbTeamGroup = db.TeamGroups.Where(t => t.Uid == MTeamGroup.Uid).FirstOrDefault();
if (DbTeamGroup == null)
{
var NetworkUser = Users.ActiveUsers.Find(x => x.NetworkId == NetworkClient.Id);
MTeamGroup.User = db.Users.FirstOrDefault(u => u.Login == NetworkUser.Login);
db.TeamGroups.Add(MTeamGroup);
db.SaveChanges();
Debug.Log($"В базу данных добавлена новая команда:\n" +
$"Id - {MTeamGroup.Id}\n" +
$"Uid - {MTeamGroup.Uid}\n" +
$"Title - {MTeamGroup.Title}\n" +
$"UserId - {MTeamGroup.UserId}", ConsoleColor.Magenta);
Sender.Broadcast("TeamGroup.Add.Confirm", MTeamGroup);
return;
}
Sender.Send(NetworkClient, "TeamGroup.Add.Error");
return;
}
}
catch (DbUpdateException ex)
{
Debug.LogError("Возникла ошибка при добавлении команды в базу данных! Код ошибки:\n" + ex);
Sender.Send(NetworkClient, "TeamGroup.Add.Error");
}
}
