/// <summary>
/// Cancel a user fb
/// </summary>
/// <param name="order">The info to cancel the user fb</param>
/// See <see cref="Areas.Bet.Models.CancelUserFootballBet"/> to know the param structure
/// <returns>The IActionResult of the cancel a user fb action</returns>
/// See <see cref="Areas.GroupManage.Models.GroupPage"/> to know the response structure
public IActionResult cancelUserFootballBet([FromBody] CancelUserFootballBet order)
{
User caller = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!caller.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(caller, _context))
{
return(BadRequest("notAllowed"));
}
UserGroup ugCaller = new UserGroup();
Group group = new Group();
FootballBet footballBet = new FootballBet();
UserFootballBet userFootballBet = new UserFootballBet();
if (!UserInFootballBet.check(caller, ref group, order.groupName, ref ugCaller, ref footballBet, order.footballBet, _context, false))
{
return(BadRequest());
}
if (footballBet.cancelled)
{
return(BadRequest(new { error = "CancelBetCancelled" }));
}
if (footballBet.ended)
{
return(BadRequest(new { error = "CancelBetEnded" }));
}
if (footballBet.dateLastBet < DateTime.Now)
{
return(BadRequest(new { error = "CancelBetLastBetPassed" }));
}
if (!checkBet(ref userFootballBet, order.userBet, footballBet, caller))
{
return(BadRequest());
}
try
{
ugCaller.coins += CheckBetType.calculateCancelRate(footballBet, userFootballBet.bet, _context);
userFootballBet.valid = false;
userFootballBet.dateInvalid = DateTime.Now;
_context.Update(ugCaller);
_context.Update(userFootballBet);
_context.SaveChanges();
return(Ok(GroupPageManager.GetPage(caller, group, _context)));
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Kick a user out from the group
/// </summary>
/// <param name="order">The info to kick a user from the group</param>
/// See <see cref="Areas.GroupManage.Models.KickUser"/> to know the param structure
/// <returns>The updated group page</returns>
/// See <see cref="Areas.GroupManage.Models.GroupPage"/> to know the response structure
public async System.Threading.Tasks.Task <IActionResult> removeUserAsync([FromBody] KickUser order)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context); //The user who tries to kick the user from the group
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
UserGroup targetUser = new UserGroup();
Group group = new Group();
if (!GroupAdminFuncionlities.checkFuncionality(user, ref group, order.groupName, ref targetUser, order.publicId, _context, GroupAdminFuncionality.REMOVE_USER, false))
{
return(BadRequest());
}
if (!group.open)
{
return(BadRequest(new { error = "GroupBanned" }));
}
try
{
_context.Entry(targetUser).Reference("User").Load();
User sendNew = targetUser.User;
Guid targetUserid = targetUser.User.id;
await QuitUserFromGroup.quitUser(targetUser, _context, _notificationHub);
await KickChatNotification.sendKickMessageAsync(group.name, targetUser.User.publicid, _chatHub);
InteractionManager.manageInteraction(targetUser.User, group, interactionType.KICKED, _context);
using (var scope = _scopeFactory.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService <ApplicationDBContext>();
group = dbContext.Group.Where(g => g.name == order.groupName).First();
User recv = dbContext.User.Where(u => u.id == targetUserid).First();
user = dbContext.User.Where(u => u.id == user.id).First();
Home.Util.GroupNew.launch(sendNew, group, null, Home.Models.TypeGroupNew.KICK_USER_USER, false, dbContext);
Home.Util.GroupNew.launch(sendNew, group, null, Home.Models.TypeGroupNew.KICK_USER_GROUP, false, dbContext);
await SendNotification.send(_notificationHub, group.name, recv, NotificationType.KICKED_GROUP, dbContext);
return(Ok(GroupPageManager.GetPage(user, group, dbContext)));
}
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Get all the users from the database who are not admin users
/// </summary>
/// <returns>A list with all the not-admin users</returns>
/// See <see cref="Areas.Admin.Models.UserSearchInfo"/> to know the response structure
public List <UserSearchInfo> getAllUsers()
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!AdminPolicy.isAdmin(user, _context))
{
return(new List <UserSearchInfo>());
}
List <UserSearchInfo> userRet = new List <UserSearchInfo>();
Role adminRole = RoleManager.getAdmin(_context);
return(MakeListUserSearchInfo.make(_context.User.Where(u => u.role != adminRole).Take(25).ToList(), _context));
}
/// <summary>
/// Get all the groups that the user is not join in
/// </summary>
/// <returns>A list with the groups that the user is not join in</returns>
/// See <see cref="Areas.GroupManage.Models.GroupInfo"/> to see the response structure
public List <GroupInfo> getAllGroups()
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!user.open)
{
return(new List <GroupInfo>());
}
bool isAdmin = AdminPolicy.isAdmin(user, _context);
List <Group> groups = !isAdmin?_context.Group.Where(g => g.open).Take(25).ToList()
: _context.Group.Take(25).ToList();
return(MakeGroupInfoList.make(groups, AdminPolicy.isAdmin(user, _context), _context));
}
/// <summary>
/// Change the info of the user
/// </summary>
/// <param name="info">The new info of the user</param>
/// See <see cref="Areas.UserInfo.Models.ChangeUserInfo"/> to know the param structure
/// <returns>IActionResult of the change user info action</returns>
/// See <see cref="Areas.UserInfo.Models.UserData"/> to know the response structure
public IActionResult changeUser([FromBody] ChangeUserInfo info)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
bool isAdmin = AdminPolicy.isAdmin(user, _context);
try {
user.nickname = !isAdmin?changeNickname(info.nickname, user.nickname) : user.nickname;
user.password = changePassword(info.oldpassword, info.newPassword, user.password);
user.profileImg = !isAdmin ? info.image ?? user.profileImg : user.profileImg;
_context.Update(user);
_context.SaveChanges();
} catch (DbUpdateException) {
return(StatusCode(500));
} catch (Exception e) {
if (e.Message == "")
{
return(BadRequest());
}
else
{
return(BadRequest(new { error = e.Message }));
}
}
string successRes = "";
if (_changePass)
{
successRes = "PassChanged";
}
UserData userShow = new UserData
{
email = user.email,
nickname = user.nickname,
img = user.profileImg,
groups = GroupsOfUser.get(user, _context),
timeSignUp = user.dateSignUp
};
return(Ok(new { success = successRes, info = userShow }));
}
/// <summary>
/// Block/unblock a user from the group
/// </summary>
/// <param name="order">The info to block/unblock the user</param>
/// See <see cref="Areas.GroupManage.Models.MakeAdmin_blockUser"/> to know the param structure
/// <returns>The updated group page</returns>
/// See <see cref="Areas.GroupManage.Models.GroupPage"/> to know the response structure
public async Task <IActionResult> blockUser([FromBody] MakeAdmin_blockUser order)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context); //The user who tries to kick the user from the group
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
UserGroup targetUser = new UserGroup();
Group group = new Group();
if (!GroupAdminFuncionlities.checkFuncionality(user, ref group, order.groupName, ref targetUser, order.publicId, _context, GroupAdminFuncionality.BLOCK_USER, order.make_unmake))
{
return(BadRequest());
}
if (!group.open)
{
return(BadRequest(new { error = "GroupBanned" }));
}
try
{
_context.Entry(user).Collection("groups").Load();
UserGroup callerUG = user.groups.Where(g => g.groupid == group.id).First();
targetUser.blocked = !targetUser.blocked;
targetUser.role = RoleManager.getGroupNormal(_context);
targetUser.blockedBy = callerUG.role;
_context.Update(targetUser);
_context.SaveChanges();
_context.Entry(targetUser).Reference("User").Load();
if (order.make_unmake)
{
await KickChatNotification.sendKickMessageAsync(group.name, targetUser.User.publicid, _chatHub);
}
await sendMessages(targetUser, group, order.make_unmake);
return(Ok(GroupPageManager.GetPage(user, group, _context)));
}
catch (Exception)
{
return(StatusCode(500));
}
}
//
// ────────────────────────────────────────────────────────────────────────────────────
// :::::: P R I V A T E F U N C T I O N S : : : : : : : :
// ────────────────────────────────────────────────────────────────────────────────────
//
/// <summary>
/// Check if the sender and receiver are correct
/// </summary>
/// <param name="sender">The maker of the dm</param>
/// <param name="recv">The receiver of the dm</param>
/// <returns>True if both are correct, false otherwise</returns>
private bool checkSenderAndReceiver(User sender, String recv)
{
bool sendToAdmin = recv == null;
bool sentFromAdmin = AdminPolicy.isAdmin(sender, _context);
if (sentFromAdmin && sendToAdmin)
{
return(false);
}
if (!sentFromAdmin && !sendToAdmin)
{
return(false);
}
return(true);
}
public void dropRole()
{
// Get role
Console.WriteLine("\nEnter role:");
String roleName = Console.ReadLine();
if (roleName != null && roleName.Length > 0)
{
AdminPolicy adminPolicy = new AdminPolicy();
client.DropRole(adminPolicy, roleName);
Console.WriteLine("\nINFO: The role has been dropped.");
}
else
{
Console.WriteLine("ERROR: Role not found!");
}
}
/// <summary>
/// Get a user out of a group
/// </summary>
/// <param name="groupName">The name of the group that the user is gonna left</param>
/// <returns>IActionResult of the leaving group action</returns>
public async System.Threading.Tasks.Task <IActionResult> leaveGroup(string groupName)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context); //The user who tries to leave the group
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
UserGroup ugCaller = new UserGroup();
Group group = new Group();
if (!UserFromGroup.isOnIt(user.id, ref group, groupName, ref ugCaller, _context))
{
return(BadRequest());
}
if (!group.open)
{
return(BadRequest(new { error = "GroupBanned" }));
}
if (!await QuitUserFromGroup.quitUser(ugCaller, _context, _hub))
{
return(StatusCode(500));
}
InteractionManager.manageInteraction(user, group, interactionType.LEAVED, _context);
using (var scope = _scopeFactory.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService <ApplicationDBContext>();
var groupE = dbContext.Group.Where(g => g.name == groupName);
if (groupE.Count() == 1)
{
Home.Util.GroupNew.launch(user, group, null, Home.Models.TypeGroupNew.JOIN_LEFT_GROUP, false, _context);
}
if (groupE.Count() == 1)
{
Home.Util.GroupNew.launch(user, group, null, Home.Models.TypeGroupNew.JOIN_LEFT_USER, false, _context);
}
}
return(Ok(new { success = "SuccesfullGroupLeave" }));
}
/// <summary>
/// Sends a message to a dm conversation
/// </summary>
/// <param name="order">The info to send the message</param>
/// See <see cref="Areas.DirectMessages.Models.SendDMMessage"/> to know the param structure
/// <returns>IActionResult of the send message action</returns>
/// See <see cref="Areas.DirectMessages.Models.DMRoom"/> to know the response structure
public async Task <IActionResult> sendMsg([FromBody] SendDMMessage order)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
DirectMessageTitle title = new DirectMessageTitle();
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (!checkOrder(ref title, order.dmId, user))
{
return(BadRequest());
}
try
{
bool isAdmin = AdminPolicy.isAdmin(user, _context);
DirectMessageMessages msg = new DirectMessageMessages
{
message = order.message,
isAdmin = isAdmin,
DirectMessageTitle = title
};
addUnreadMessages(title, isAdmin);
_context.Add(msg);
_context.SaveChanges();
await sendMailAndSendNotification(title, user);
using (var scope = _scopeFactory.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService <ApplicationDBContext>();
DirectMessageTitle dbTitle = dbContext.DirectMessagesTitle.Where(t => t.id == title.id).First();
User dbuser = dbContext.User.Where(u => u.id == user.id).First();
DMRoom room = new DMRoom(dbTitle, dbuser, dbContext);
return(Ok(room));
}
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Change the weekly pay of a group
/// </summary>
/// <param name="order">The info to change the weekly pay</param>
/// See <see cref="Areas.GroupManage.Models.ManageWeeklyPay"/> to know the param structure
/// <returns>The updated group page</returns>
/// See <see cref="Areas.GroupManage.Models.GroupPage"/> to know the response structure
public IActionResult manageWeeklyPay([FromBody] ManageWeeklyPay order)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context); //The user who tries to make admin to another user
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
Group group = new Group();
if (!GroupMakerFuncionlities.checkFuncionality(user, ref group, order.groupName, GroupMakerFuncionality.MANAGEWEEKPAY, _context, "", ""))
{
return(BadRequest());
}
if (order.weeklyPay < 100 || order.weeklyPay > 2000)
{
return(BadRequest());
}
if (!group.open)
{
return(BadRequest(new { error = "GroupBanned" }));
}
try
{
int oldPay = group.weeklyPay;
group.weeklyPay = order.weeklyPay;
_context.Update(group);
_context.SaveChanges();
launchNews_changeUserCoins(group, oldPay, order.weeklyPay, user.id);
_context.SaveChanges();
return(Ok(GroupPageManager.GetPage(user, group, _context)));
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Closes or open a dm conversation
/// </summary>
/// <param name="id">The id of the dm conversation</param>
/// <param name="openOrder">"1" to open de conversation, "0" to clse it</param>
/// <returns>The IActionResult of the open/close action</returns>
/// See <see cref="Areas.DirectMessages.Models.DMRoom"/> to know the response structure
public async Task <IActionResult> close(string id, string openOrder)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
DirectMessageTitle title = new DirectMessageTitle();
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (!AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
if (openOrder != "1" && openOrder != "0")
{
return(BadRequest());
}
bool open = openOrder == "1";
if (!checkOrder(ref title, id, open))
{
return(BadRequest());
}
if (!checkAdminInDM(title, user))
{
return(BadRequest());
}
try
{
sendClosedMessage(title, open);
title.closed = !open;
_context.SaveChanges();
await sendMailAndNotification(title, user, open);
DMRoom room = new DMRoom(title, user, _context);
return(Ok(room));
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Mange the password of the group
/// </summary>
/// <param name="order">The info to manage the password of the group</param>
/// See <see cref="Areas.GroupManage.Models.ManagePassword"/> to know the param structure
/// <returns>The updated group page</returns>
/// See <see cref="Areas.GroupManage.Models.GroupPage"/> to know the response structure
public IActionResult managePassword([FromBody] ManagePassword order)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context); //The user who tries to make admin to another user
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
Group group = new Group();
if (!GroupMakerFuncionlities.checkFuncionality(user, ref group, order.name, GroupMakerFuncionality.MANAGE_PASSWORD, _context, order.newPassword, order.oldPassword))
{
return(BadRequest());
}
if (group.password != null && !PasswordHasher.areEquals(order.oldPassword, group.password))
{
return(BadRequest(new { error = "IncorrectOldPassword" }));
}
if (!group.open)
{
return(BadRequest(new { error = "GroupBanned" }));
}
try
{
group.password = order.newPassword == null ? null : PasswordHasher.hashPassword(order.newPassword);
_context.Update(group);
_context.SaveChanges();
Home.Util.GroupNew.launch(null, group, null, Home.Models.TypeGroupNew.MAKE_PRIVATE, group.password != null, _context);
return(Ok(GroupPageManager.GetPage(user, group, _context)));
}
catch (Exception)
{
return(StatusCode(500));
}
}
public void createRole()
{
Console.WriteLine("\n********** Create Role **********\n");
int privilegeCode;
string role;
// Get username
Console.WriteLine("Enter role: ");
role = Console.ReadLine();
if (role != null && role.Length > 0)
{
// Add privilege
Console.WriteLine("Enter a privilege code\n(0 = read, 1 = read-write, 2 = read-write-udf, 4 = sys-admin, 5 = user-admin):");
privilegeCode = int.Parse(Console.ReadLine());
Privilege privilege = new Privilege();
switch (privilegeCode)
{
case 0: privilege.code = PrivilegeCode.READ; break;
case 1: privilege.code = PrivilegeCode.READ_WRITE; break;
case 2: privilege.code = PrivilegeCode.READ_WRITE_UDF; break;
//MISSING FROM API! case 3: privilege.code = PrivilegeCode.DATA_ADMIN; break;
case 4: privilege.code = PrivilegeCode.SYS_ADMIN; break;
case 5: privilege.code = PrivilegeCode.USER_ADMIN; break;
}
// Create role
AdminPolicy adminPolicy = new AdminPolicy();
Privilege[] privileges = { privilege };
//TODO: Create Role
//Exercise 7
Console.WriteLine("\nINFO: Role created!");
}
}
/// <summary>
/// Bans a user
/// </summary>
/// <param name="order">The info</param>
/// See <see cref="Areas.Admin.Models.BanUser"/> to see the param info
/// <returns>The IActionResult of the ban action</returns>
public IActionResult banUser([FromBody] BanUser order)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
User targetUser = new User();
if (!AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
if (!existUser(ref targetUser, order.publicUserId))
{
return(BadRequest());
}
if (validOrder(targetUser, order.ban))
{
return(BadRequest());
}
try
{
targetUser.open = !targetUser.open;
_context.Update(targetUser);
_context.SaveChanges();
if (order.ban)
{
manageGroups(targetUser);
}
EmailSender.sendBanNotification(targetUser.email, targetUser.nickname, order.ban);
string retMessage = order.ban ? "SuccessfullUserBan" : "SuccessfullUserUnban";
return(Ok(new { success = retMessage }));
}
catch (Exception)
{
return(BadRequest(500));
}
}
public void revokePrivilege()
{
// Get role
Console.WriteLine("\nEnter role:");
String roleName = Console.ReadLine();
if (roleName != null && roleName.Length > 0)
{
// Get new privilege
Console.WriteLine("Enter a privilege code\n(0 = read, 1 = read-write, 2 = read-write-udf, 4 = sys-admin, 5 = user-admin):");
int privilegeCode = int.Parse(Console.ReadLine());
Privilege privilege = new Privilege();
switch (privilegeCode)
{
case 0: privilege.code = PrivilegeCode.READ; break;
case 1: privilege.code = PrivilegeCode.READ_WRITE; break;
case 2: privilege.code = PrivilegeCode.READ_WRITE_UDF; break;
//MISSING FROM API! case 3: privilege.code = PrivilegeCode.DATA_ADMIN; break;
case 4: privilege.code = PrivilegeCode.SYS_ADMIN; break;
case 5: privilege.code = PrivilegeCode.USER_ADMIN; break;
}
// Create user
AdminPolicy adminPolicy = new AdminPolicy();
Privilege[] privileges = { privilege };
//TODO: Revoke Privilege
//Exercise 11
Console.WriteLine("\nINFO: The privilege has been revoked from: " + roleName);
}
else
{
Console.WriteLine("ERROR: Role not found!");
}
}
/// <summary>
/// Gives the group-admin to a member of a group
/// </summary>
/// <param name="order">The infoto make a user admin of a group</param>
/// See <see cref="Areas.GroupManage.Models.MakeAdmin_blockUser"/> to know the param structure
/// <returns>The updated group page</returns>
/// See <see cref="Areas.GroupManage.Models.GroupPage"/> to know the response structure
public async Task <IActionResult> makeAdmin([FromBody] MakeAdmin_blockUser order)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context); //The user who tries to make admin to another user
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
UserGroup targetUser = new UserGroup();
Group group = new Group();
if (!GroupAdminFuncionlities.checkFuncionality(user, ref group, order.groupName, ref targetUser, order.publicId, _context, GroupAdminFuncionality.MAKE_ADMIN, order.make_unmake))
{
return(BadRequest());
}
if (!group.open)
{
return(BadRequest(new { error = "GroupBanned" }));
}
try
{
targetUser.role = order.make_unmake ? RoleManager.getGroupAdmin(_context) : RoleManager.getNormalUser(_context);
_context.Update(targetUser);
_context.SaveChanges();
await sendNews(targetUser, group, order.make_unmake);
return(Ok(GroupPageManager.GetPage(user, group, _context)));
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Get the info to launch a new fb
/// </summary>
/// <param name="groupName">The name of the group where the new bet wants to be launched</param>
/// <returns>IActionResult of the get fb page action</returns>
/// See <see cref="Areas.GroupManage.Models.LaunchFootballBetManager"/> to know the response structure
public IActionResult getFootBallPage([Required] string groupName)
{
User caller = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!caller.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(caller, _context))
{
return(BadRequest("notAllowed"));
}
Group group = new Group();
if (!GroupMakerFuncionlities.checkFuncionality(caller, ref group, groupName, GroupMakerFuncionality.STARTCREATE_FOOTBALL_BET, _context))
{
return(BadRequest());
}
if (!checkMaxBetAllowed(group))
{
return(Ok(getMaxReachResponse()));
}
try
{
List <FootballMatch> availableMatches = getAvailableMatchDays(group);
LaunchFootballBetManager response = new LaunchFootballBetManager();
response.typeBets = loadTypeFootballBet();
response.typePays = loadTypePays();
response.competitionMatches = getAvailableBets(availableMatches);
return(Ok(response));
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Deletes a group
/// </summary>
/// <param name="order">The info to remove a group</param>
/// See <see cref="Areas.GroupManage.Models.RemoveGroup"/> to know the param structure
/// <returns>IActionResult of the remove group action</returns>
public IActionResult removeGroup([FromBody] Models.RemoveGroup order)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context); //The user who tries to kick the user from the group
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
Group group = new Group();
if (!GroupMakerFuncionlities.checkFuncionality(user, ref group, order.name, GroupMakerFuncionality.REMOVE_GROUP, _context))
{
return(BadRequest());
}
if (!PasswordHasher.areEquals(order.userPassword, user.password))
{
return(BadRequest(new { error = "IncorrectOldPassword" }));
}
if (!group.open)
{
return(BadRequest(new { error = "GroupBanned" }));
}
try
{
RemoveGroup.remove(group, _context, _hub);
return(Ok(new { success = "SuccesfullGroupRemoved" }));
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Removes a account of a user
/// </summary>
/// <param name="userDelete">Removes the account of a user</param>
/// See <see cref=""/> to know the param structure
/// <returns>IActionResult of the delete account action</returns>
public async Task <IActionResult> deleteAccount([FromBody] DeleteUser userDelete)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
string userDeletePass = PasswordHasher.hashPassword(userDelete.password);
if (user.password != userDeletePass)
{
return(BadRequest(new { error = "CantDeleteAccount" }));
}
if (!await deleteAccountBeingNormal(user))
{
return(BadRequest(new { error = "CantDeleteAccount" }));
}
try {
user.dateDeleted = DateTime.Now;
_context.SaveChanges();
removeTitles(user);
removeNotifications(user);
} catch (Exception) {
return(StatusCode(500));
}
return(Ok());
}
/// <summary>
/// Get a list of groups with a similar name
/// </summary>
/// <param name="name">The name of the group to find</param>
/// <returns>A list of group with a similar name</returns>
/// See <see cref="Areas.GroupManage.Models.GroupInfo"/> to see the response structure
public List <GroupInfo> searchGroupByName(string name)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
name = name.ToLower().Trim();
if (!user.open)
{
return(new List <GroupInfo>());
}
//The request name is empty
if (name == null || name.Length == 0)
{
return(new List <GroupInfo>());
}
bool isAdmin = AdminPolicy.isAdmin(user, _context);
List <Group> groupsWithTheSameName = !isAdmin?
_context.Group.Where(g => g.name.ToLower().Contains(name) && g.open).ToList() :
_context.Group.Where(g => g.name.ToLower().Contains(name)).ToList();
return(MakeGroupInfoList.make(groupsWithTheSameName, AdminPolicy.isAdmin(user, _context), _context));
}
/// <summary>
/// Search a specific user
/// </summary>
/// <param name="toFind">The username or email of the user to find</param>
/// <returns>A list with all the not-admin users who username or email match with the param</returns>
/// See <see cref="Areas.Admin.Models.UserSearchInfo"/> to know the response structure
public List <UserSearchInfo> searchUser(string toFind)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!AdminPolicy.isAdmin(user, _context))
{
return(new List <UserSearchInfo>());
}
//The request name is empty
if (toFind == null || toFind.Length == 0)
{
return(new List <UserSearchInfo>());
}
Role adminRole = RoleManager.getAdmin(_context);
List <User> userWithSameMail = _context.User.Where(u =>
(u.email.ToLower().Contains(toFind.ToLower().Trim()) ||
u.nickname.ToLower().Contains(toFind.ToLower().Trim())) &&
u.role != adminRole
).ToList();
return(MakeListUserSearchInfo.make(userWithSameMail, _context));
}
/// <summary>
/// Get the page of the group
/// </summary>
/// <param name="groupName">The name of the group</param>
/// <returns>The updated group page</returns>
/// See <see cref="Areas.GroupManage.Models.GroupPage"/> to know the response structure
public IActionResult getGroupPage(string groupName)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
var groups = _context.Group.Where(g => g.name == groupName);
// If the group doesn't exist
if (groups.Count() != 1)
{
return(BadRequest());
}
Group group = groups.First();
_context.Entry(group).Collection("users").Load();
// If the user doesn't belong to the group
if (group.users.Where(u => u.userid == user.id && !u.blocked).Count() != 1)
{
return(BadRequest());
}
if (!group.open)
{
return(BadRequest(new { error = "GroupBanned" }));
}
return(Ok(GroupPageManager.GetPage(user, group, _context)));
}
/// <summary>
/// Get the news for not logged users
/// </summary>
/// <returns>The IActionResult of the get the not logged news action</returns>
/// See <see cref="Areas.Home.Models.NewMessage"/> to see the response structure
public IActionResult GetStand()
{
bool isAdmin;
try
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
isAdmin = AdminPolicy.isAdmin(user, _context);
}
catch (Exception)
{
isAdmin = false;
}
try
{
List <NewMessage> retMessage = GetNews.getStandNews(isAdmin, _context);
return(Ok(retMessage));
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Get the news for auhtorized users
/// </summary>
/// <returns>The IActionResult of the get authorized news action</returns>
/// See <see cref="Areas.Home.Models.NewMessage"/> to see the response structure
public IActionResult getAuth()
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
try
{
List <NewMessage> retMessage = GetNews.getAuthNews(user.id, _context);
return(Ok(retMessage));
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Copy admin policy from another admin policy.
/// </summary>
public AdminPolicy(AdminPolicy other)
{
this.timeout = other.timeout;
}
/// <summary>
/// Launchs a new fb
/// </summary>
/// <param name="order">The info to launch a new fb</param>
/// See <see cref="Areas.Bet.Models.LaunchFootballBet"/> to know the param structure
/// <returns>IActionResult of the launch fb action</returns>
/// See <see cref="Areas.GroupManage.Models.GroupPage"/> to know the response structure
public IActionResult launchBet([FromBody] LaunchFootballBet order)
{
User caller = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!caller.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(caller, _context))
{
return(BadRequest("notAllowed"));
}
Group group = new Group();
MatchDay match = new MatchDay();
TypeFootballBet typeBet = new TypeFootballBet();
TypePay typePay = new TypePay();
if (!GroupMakerFuncionlities.checkFuncionality(caller, ref group, order.groupName, GroupMakerFuncionality.STARTCREATE_FOOTBALL_BET, _context))
{
return(BadRequest());
}
if (!getMatchDay(ref match, order.matchday))
{
return(BadRequest());
}
if (!checkMaxBetAllowed(group))
{
return(BadRequest());
}
if (!checkParams(ref typeBet, order.typeBet, ref typePay, order.typePay))
{
return(BadRequest());
}
if (order.lastBetTime > match.date)
{
return(BadRequest());
}
if (!checkMaxMin(order.minBet, order.maxBet))
{
return(BadRequest());
}
try
{
FootballBet fb = new FootballBet
{
MatchDay = match,
Group = group,
type = typeBet,
typePay = typePay,
minBet = order.minBet,
maxBet = order.maxBet,
winRate = typeBet.winRate + typePay.winRate,
dateLastBet = order.lastBetTime,
dateEnded = match.date
};
_context.Add(fb);
_context.SaveChanges();
launchNews(caller, group, fb);
return(Ok(GroupPageManager.GetPage(caller, group, _context)));
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Create a new group
/// </summary>
/// <param name="groupName">The name of the new group</param>
/// <returns>The IActionResult of the create group action</returns>
public IActionResult createGroup([Required][MaxLength(30)][MinLength(4)] string groupName)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
//Group with the same name
var dbGroup = _context.Group.Where(g => g.name == groupName);
if (dbGroup.Count() > 0) //If already exists a group with the same name
{
return(BadRequest());
}
if (!canCreateANewGroup(user))
{
return(BadRequest(new { error = "LimitationCreateGroup" }));
}
if (!canCreateAGroup(user)) //The user cant create more groups right now
{
return(BadRequest(new { error = "LimitationTimeCreateGroup" }));
}
try
{
Group newGroup = new Group {
name = groupName
};
UserGroup userG = new UserGroup {
User = user,
Group = newGroup,
role = RoleManager.getGroupMaker(_context),
dateRole = DateTime.Today,
coins = newGroup.weeklyPay
};
user.lastTimeCreateGroup = DateTime.Now;
_context.Add(newGroup);
_context.Add(userG);
_context.SaveChanges();
Home.Util.GroupNew.launch(user, newGroup, null, Home.Models.TypeGroupNew.CREATE_GROUP_GROUP, false, _context);
Home.Util.GroupNew.launch(user, newGroup, null, Home.Models.TypeGroupNew.CREATE_GROUP_USER, false, _context);
return(Ok(new { success = "SuccesfullCreatedGroup" }));
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Join a user to a group
/// </summary>
/// <param name="order">The info to join to a group</param>
/// See <see cref="Areas.GroupManage.Models.JoinGroup"/> to know the param structure
/// <returns>IActionResult of the joining group action</returns>
public IActionResult joinGroup([FromBody] JoinGroup order)
{
User user = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!user.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(user, _context))
{
return(BadRequest("notAllowed"));
}
Group group = new Group();
if (!isUnderLimitations(user))
{
return(BadRequest(new { error = "MaxGroupJoinsReached" }));
}
if (!hasPermissions(user, ref group, order.groupName))
{
return(BadRequest());
}
if (group.password != null && !PasswordHasher.areEquals(order.password, group.password))
{
return(BadRequest(new { error = "IncorrectPasswordJoiningGroup" }));
}
if (!group.open)
{
return(BadRequest(new { error = "GroupBanned" }));
}
interactionType type = checkInteractions(user, group);
if (type != interactionType.NONE)
{
if (type == interactionType.KICKED)
{
return(BadRequest(new { error = "YouwereKickedGroup" }));
}
else
{
return(BadRequest(new { error = "YouhasleavedGroup" }));
}
}
try
{
UserGroup newUser = new UserGroup
{
User = user,
Group = group,
role = RoleManager.getGroupNormal(_context),
dateRole = DateTime.Today,
coins = group.weeklyPay
};
_context.UserGroup.Add(newUser);
_context.SaveChanges();
Home.Util.GroupNew.launch(user, group, null, Home.Models.TypeGroupNew.JOIN_LEFT_GROUP, true, _context);
Home.Util.GroupNew.launch(user, group, null, Home.Models.TypeGroupNew.JOIN_LEFT_USER, true, _context);
return(Ok(new { success = "SuccesfullJoinGroup" }));
}
catch (Exception)
{
return(StatusCode(500));
}
}
/// <summary>
/// Do a user fb on a fb
/// </summary>
/// <param name="order">The info to do the user fb</param>
/// See <see cref="Areas.Bet.Models.DoFootballBet"/> to know the param structure
/// <returns>IActionResult of the do user fb action</returns>
/// See <see cref="Areas.GroupManage.Models.GroupPage"/> to know the response structure
public IActionResult doFootballBet([FromBody] DoFootballBet order)
{
User caller = TokenUserManager.getUserFromToken(HttpContext, _context);
if (!caller.open)
{
return(BadRequest(new { error = "YoureBanned" }));
}
if (AdminPolicy.isAdmin(caller, _context))
{
return(BadRequest("notAllowed"));
}
UserGroup ugCaller = new UserGroup();
Group group = new Group();
FootballBet fb = new FootballBet();
if (!UserInFootballBet.check(caller, ref group, order.groupName, ref ugCaller, ref fb, order.footballbet, _context))
{
return(BadRequest());
}
if (fb.cancelled)
{
return(BadRequest(new { error = "BetCancelled" }));
}
if (fb.ended)
{
return(BadRequest(new { error = "BetEnded" }));
}
if (fb.dateLastBet < DateTime.Now)
{
return(BadRequest(new { error = "BetLastBetPassed" }));
}
if (!checkBet(order.bet, ugCaller.coins, fb))
{
return(BadRequest());
}
if (!checkTypePriceWithBet(fb, order.homeGoals, order.awayGoals, order.winner))
{
return(BadRequest());
}
try
{
_context.Add(new UserFootballBet
{
FootballBet = fb,
User = caller,
bet = order.bet,
winner = order.winner,
homeGoals = order.homeGoals,
awayGoals = order.awayGoals
});
fb.usersJoined++;
ugCaller.coins -= order.bet;
_context.Update(ugCaller);
_context.Update(fb);
_context.SaveChanges();
return(Ok(GroupPageManager.GetPage(caller, group, _context)));
}
catch (Exception)
{
return(StatusCode(500));
}
}