public async Task <IActionResult> AddOrUpdateListPermission([FromBody] object listPermission)
{
Tuple <string, string, string> tupel =
JsonConvert.DeserializeObject <Tuple <string, string, string> >(listPermission.ToString());
string thisUserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
string targetUserEMail = tupel.Item1;
User user = _userService.GetByEMail(targetUserEMail);
if (user != null)
{
string targetUserId = _userService.GetByEMail(targetUserEMail).Id;
string shoppingListId = tupel.Item2;
ShoppingListPermissionType permission =
(ShoppingListPermissionType)Enum.Parse(typeof(ShoppingListPermissionType), tupel.Item3, true);
bool success = await _shoppingService.AddOrUpdateListPermission(thisUserId, targetUserId, shoppingListId, permission, true);
if (success)
{
return(Ok());
}
}
return(BadRequest(new { message = "Permission Change not possible." }));
}
public List <ShoppingList> GetLists(string userId, ShoppingListPermissionType permission)
{
var query = from list in _db.Set <ShoppingList>()
join perm in _db.Set <ShoppingListPermission>() on list.SyncId equals perm.ShoppingListId
where perm.UserId.Equals(userId) && perm.PermissionType.HasFlag(permission)
select list;
List <ShoppingList> listEntities = query.ToList();
List <ShoppingList> lists = new List <ShoppingList>();
foreach (ShoppingList listEntity in listEntities)
{
ShoppingList list = LoadShoppingList(listEntity.SyncId);
//var queryOwner = from perm in list.ShoppingListPermissions
// where perm.PermissionType == ShoppingListPermissionType.All
// select perm.User;
//var queryOwner = from list in _db.Set<ShoppingList>()
// join perm in _db.Set<ShoppingListPermission>() on list.SyncId equals perm.ShoppingListId
// where perm.PermissionType == ShoppingListPermissionType.All
if (list != null)
{
lists.Add(list);
}
}
return(lists);
}
// Send the given list to all users that have the given permission on that list, e.g.
// if permission == Read then it's send to all users that have read permission on that list.
public async Task SendListUpdated(User user, ShoppingList list, ShoppingListPermissionType permission)
{
string userJson = JsonConvert.SerializeObject(user.WithoutPassword());
string listJson = JsonConvert.SerializeObject(list);
List <string> users = GetUsersWithPermissionsFiltered(user, list.SyncId, permission);
await _hubContext.Clients.Users(users).SendAsync("ListUpdated", userJson, listJson);
}
public NoShoppingListPermissionException(ShoppingListPermission _permission, ShoppingListPermissionType _expectedPermission)
{
Permission = _permission;
ExpectedPermission = _expectedPermission;
Console.Error.WriteLine("NoShoppingListPermissionException ShoppingListId " + _permission.ShoppingListId + "UserId " + _permission.UserId);
}
private void CheckPermissionWithException(ShoppingList list, string userId, ShoppingListPermissionType expectedPermission)
{
ShoppingListPermission permission = GetPermission(list, userId);
if (!CheckPermission(permission, expectedPermission))
{
throw new NoShoppingListPermissionException(permission, expectedPermission);
}
}
// Adds the given list permission to target user. Performed by thisUser (thisUser needs permission to change permissions of the given list!)
// If target use has no permission yet, they get a message that a new list was added instead of just a permission change.
// \param thisUser - the user who tries to change the permission
// \param targetUser - the user whose permission should be changed
// \param shoppingListId - id of the list whose permission is changed
// \param permission - target permission type
public async Task <bool> AddOrUpdateListPermission(
string thisUserId, string targetUserId, string shoppingListId, ShoppingListPermissionType permission, bool checkPermission = true)
{
ShoppingList targetList = GetShoppingListEntity(shoppingListId);
if (targetList == null)
{
throw new ShoppingListNotFoundException(shoppingListId);
}
if (checkPermission)
{
CheckPermissionWithException(targetList, thisUserId, ShoppingListPermissionType.ModifyAccess);
}
// TODO: actually move a list if the owner is changed with that method
var query = from list in _db.Set <ShoppingList>()
join perm in _db.Set <ShoppingListPermission>()
on list.SyncId equals perm.ShoppingListId
where perm.UserId.Equals(targetUserId) && perm.ShoppingListId.Equals(shoppingListId)
select new { list, perm };
var first = query.FirstOrDefault();
if (first != null)
{
first.perm.PermissionType = permission;
}
else
{
ShoppingList list = GetShoppingListEntity(shoppingListId);
if (list == null)
{
throw new ShoppingListNotFoundException(shoppingListId);
}
list.ShoppingListPermissions.Add(new ShoppingListPermission
{
ShoppingListId = shoppingListId,
UserId = targetUserId,
PermissionType = permission
});
}
_db.SaveChanges();
if (first != null)
{
await _hubService.SendListPermissionChanged(_userService.GetById(thisUserId), shoppingListId, targetUserId, permission);
}
else
{
targetList = LoadShoppingList(shoppingListId);
await _hubService.SendListAdded(_userService.GetById(thisUserId), targetList, ShoppingListPermissionType.Read);
}
return(true);
}
public IActionResult GetUserListPermission(string listId, string userId)
{
string thisUserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
ShoppingListPermissionType permission = _shoppingService.GetUserListPermission(listId, thisUserId, userId);
if (permission != ShoppingListPermissionType.Undefined)
{
return(Ok(permission.ToString()));
}
else
{
return(BadRequest(new { message = "Not Found" }));
}
}
public List <string> GetUsersWithPermissions(string listSyncId, ShoppingListPermissionType permission)
{
List <Tuple <string, ShoppingListPermissionType> > tuples = GetListPermissions(listSyncId);
List <string> users = new List <string>();
foreach (Tuple <string, ShoppingListPermissionType> tuple in tuples)
{
if (tuple.Item2.HasFlag(permission))
{
users.Add(tuple.Item1);
}
}
return(users);
}
// Inform the given user that its permission for the given list changed.
public async Task <bool> SendListPermissionChanged(
User thisUser,
string listSyncId,
string targetUserId,
ShoppingListPermissionType permission)
{
try
{
string userJson = JsonConvert.SerializeObject(thisUser.WithoutPassword());
await _hubContext.Clients.Users(targetUserId).SendAsync("ListPermissionChanged", userJson, listSyncId, permission);
return(true);
}
catch (Exception ex)
{
Console.Error.WriteLine("SendListPermissionChanged {0}", ex);
return(false);
}
}
public async Task <bool> SendItemNameChanged(
User user,
string newItemName,
string oldItemName,
string listSyncId,
ShoppingListPermissionType permission)
{
try
{
string userJson = JsonConvert.SerializeObject(user.WithoutPassword());
List <string> users = GetUsersWithPermissionsFiltered(user, listSyncId, permission);
await _hubContext.Clients.Users(users).SendAsync("ItemNameChanged", userJson, listSyncId, newItemName, oldItemName);
return(true);
}
catch (Exception ex)
{
Console.Error.WriteLine("SendItemNameChanged {0}", ex);
return(false);
}
}
public async Task <bool> SendProductAddedOrUpdated(
User user,
GenericProduct product,
string listSyncId,
ShoppingListPermissionType permission)
{
try
{
string userJson = JsonConvert.SerializeObject(user.WithoutPassword());
string productJson = JsonConvert.SerializeObject(product);
List <string> users = GetUsersWithPermissionsFiltered(user, listSyncId, permission);
await _hubContext.Clients.Users(users).SendAsync("ProductAddedOrUpdated", userJson, listSyncId, productJson);
return(true);
}
catch (Exception ex)
{
Console.Error.WriteLine("SendProductAddedOrUpdatedn {0}", ex);
return(false);
}
}
public async Task SendListPropertyChanged(User user, string listSyncId, string propertyName, string propertyValue, ShoppingListPermissionType permission)
{
string userJson = JsonConvert.SerializeObject(user.WithoutPassword());
List <string> users = GetUsersWithPermissionsFiltered(user, listSyncId, permission);
await _hubContext.Clients.Users(users).SendAsync("ListPropertyChanged", userJson, listSyncId, propertyName, propertyValue);
}
private List <string> GetUsersWithPermissionsFiltered(User filteredUser, string listSyncId, ShoppingListPermissionType permission)
{
List <string> users = _shoppingService.Value.GetUsersWithPermissions(listSyncId, permission);
users.Remove(filteredUser.Id);
return(users);
}
private bool CheckPermission(ShoppingList list, string userId, ShoppingListPermissionType expectedPermission)
{
return(CheckPermission(GetPermission(list, userId), expectedPermission));
}
private bool CheckPermission(ShoppingListPermission permission, ShoppingListPermissionType expectedPermission)
{
return(permission != null && permission.PermissionType.HasFlag(expectedPermission));
}
public ShoppingListWithPermissionDTO(ShoppingList list, string userId, ShoppingListPermissionType permission)
{
List = list;
UserId = userId;
Permission = permission;
}
