// ShareAlbum <albumId> <username> <permission>
// For example:
// ShareAlbum 4 dragon321 Owner
// ShareAlbum 4 dragon11 Viewer
public static string Execute(string[] data, Session session)
{
if (!session.IsLoggedIn())
{
throw new InvalidOperationException("Invalid credentials!");
}
int albumId = int.Parse(data[0]);
string username = data[1];
string permissionInput = data[2];
using (PhotoShareContext context = new PhotoShareContext())
{
Album album = context.Albums
.Find(albumId);
if (album == null)
{
throw new ArgumentException($"Album with Id {albumId} not found!");
}
User user = context.Users
.FirstOrDefault(u => u.Username == username);
if (user == null)
{
throw new ArgumentException($"User {username} not found!");
}
if (user.Username != session.User.Username)
{
throw new InvalidOperationException("Invalid credentials!");
}
Role permission;
if (!Enum.TryParse(permissionInput, out permission))
{
throw new ArgumentException("Permission must be either “Owner” or “Viewer”!");
}
AlbumRole newAlbumRole = new AlbumRole()
{
Album = album,
User = user,
Role = permission
};
if (context.AlbumRoles.Any(ar => ar.Album == newAlbumRole.Album && ar.User == newAlbumRole.User))
{
throw new ArgumentException($"Album {album.Name} already shared to {user.Username} with role {permission}");
}
context.AlbumRoles.Add(newAlbumRole);
context.SaveChanges();
return($"Username {user.Username} added to album {album.Name} ({permission})");
}
}
private void SetPassword(User user, string newPassword)
{
using (var context = new PhotoShareContext())
{
user.Password = newPassword;
context.Users.Update(user);
context.SaveChanges();
}
}
// RegisterUser <username> <password> <repeat-password> <email>
public static string Execute(string[] data)
{
string username = data[1];
string password = data[2];
string repeatPassword = data[3];
string email = data[4];
if (data.Length < 5)
{
throw new IndexOutOfRangeException($"Command {data[0]} not valid!");
}
if (Session.User != null)
{
throw new InvalidOperationException("Invalid Credentials!");
}
if (password != repeatPassword)
{
throw new ArgumentException("Passwords do not match!");
}
using (var db = new PhotoShareContext())
{
//var checkUser = db.Users
// .AsNoTracking()
// .Where(e => e.Username == username)
// .FirstOrDefault();
//if (checkUser != null)
//{
// throw new InvalidOperationException($"Username {username} is already taken!");
//}
if (db.Users.Any(e => e.Username == username))
{
throw new InvalidOperationException($"Username {username} is already taken!");
}
}
User user = new User
{
Username = username,
Password = password,
Email = email,
IsDeleted = false,
RegisteredOn = DateTime.Now,
LastTimeLoggedIn = DateTime.Now
};
using (PhotoShareContext context = new PhotoShareContext())
{
context.Users.Add(user);
context.SaveChanges();
}
return("User " + user.Username + " was registered successfully!");
}
// ShareAlbum <albumId> <username> <permission>
// For example:
// ShareAlbum 4 dragon321 Owner
// ShareAlbum 4 dragon11 Viewer
public static string Execute(string[] data)
{
var albumId = int.Parse(data[1]);
var userName = data[2];
var permission = data[3].ToLower();
if (data.Length < 4)
{
throw new IndexOutOfRangeException($"Command {data[0]} not valid!");
}
using (var db = new PhotoShareContext())
{
var album = db.Albums.FirstOrDefault(e => e.Id == albumId);
if (album == null)
{
throw new ArgumentException($"Album {albumId} not found!");
}
var user = db.Users.FirstOrDefault(e => e.Username == userName);
if (Session.User.Username != userName)
{
throw new ArgumentException("Invalid credentials!");
}
if (user == null)
{
throw new ArgumentException($"User {userName} not found!");
}
var albumRole = new AlbumRole();
switch (permission)
{
case "owner":
albumRole.Album = album;
albumRole.User = user;
albumRole.Role = Role.Owner;
break;
case "viewer":
albumRole.Album = album;
albumRole.User = user;
albumRole.Role = Role.Viewer;
break;
default:
throw new ArgumentException("Permission must be either “Owner” or “Viewer”!");
}
db.AlbumRoles.Add(albumRole);
db.SaveChanges();
return($"Username {userName} added to album {album.Name} ({permission})");
}
}
public bool IsPicExisting(string albumName, string picTitle, string pictureFilePath)
{
using (PhotoShareContext context = new PhotoShareContext())
{
return(context.Albums.SingleOrDefault(alb => alb.Name == albumName)
.Pictures
.Any(p => p.Title == picTitle && p.Path == pictureFilePath));
}
}
// AcceptFriend <username1> <username2>
public override string Execute(string[] data, PhotoShareContext context)
{
string receiverUsername = data[0];
string senderUsername = data[1];
User receiver = context
.Users
.Include(u => u.FriendsAdded)
.ThenInclude(f => f.Friend)
.Include(u => u.AddedAsFriendBy)
.ThenInclude(f => f.Friend)
.SingleOrDefault(u => u.Username.Equals(receiverUsername));
if (receiver == null)
{
throw new ArgumentException($"{receiverUsername} not found!");
}
if (!Helpers.IsUserTheCurrentlyLoggedOne(receiver))
{
throw new InvalidOperationException("Invalid credentials!");
}
User sender = context
.Users
.Include(u => u.FriendsAdded)
.ThenInclude(f => f.Friend)
.Include(u => u.AddedAsFriendBy)
.ThenInclude(f => f.Friend)
.SingleOrDefault(u => u.Username.Equals(senderUsername));
if (sender == null)
{
throw new ArgumentException($"{senderUsername} not found!");
}
if (receiver.FriendsAdded.Any(f => f.Friend.Username.Equals(senderUsername)))
{
throw new InvalidOperationException($"{senderUsername} is already a friend to {receiverUsername}!");
}
if (!sender.FriendsAdded.Any(f => f.Friend.Username.Equals(receiverUsername)))
{
throw new InvalidOperationException($"{senderUsername} has not added {receiverUsername} as a friend!");
}
Friendship friendship = new Friendship
{
User = receiver,
Friend = sender
};
receiver.FriendsAdded.Add(friendship);
context.SaveChanges();
return($"{receiverUsername} accepted {senderUsername} as a friend.");
}
public void UpdateCurrentTown(User updatedUser)
{
using (PhotoShareContext context = new PhotoShareContext())
{
context.Users.SingleOrDefault(u => u.Id == updatedUser.Id).CurrentTown =
context.Towns.FirstOrDefault(t => t.Id == updatedUser.CurrentTown.Id);
context.SaveChanges();
}
}
private void SetBornTown(User currentUser, Town userTown)
{
using (var context = new PhotoShareContext())
{
currentUser.BornTown = userTown;
context.Users.Update(currentUser);
context.SaveChanges();
}
}
// ModifyUser <username> <property> <new value>
// For example:
// ModifyUser <username> Password <NewPassword>
// ModifyUser <username> BornTown <newBornTownName>
// ModifyUser <username> CurrentTown <newCurrentTownName>
// !!! Cannot change username
public string Execute(string[] data)
{
if (data.Length != 3)
{
throw new InvalidOperationException("Command ModifyUser not valid!");
}
string username = data[0];
string property = data[1];
string value = data[2];
if (Session.LoggedUser == null || username != Session.LoggedUser.Username)
{
throw new InvalidOperationException("Invalid credentials!");
}
using (var context = new PhotoShareContext())
{
var user = context.Users
.Include(u => u.BornTown)
.Include(u => u.CurrentTown)
.SingleOrDefault(u => u.Username == username);
if (user == null)
{
throw new ArgumentException($"User {username} not found!");
}
if (property.Contains("Town") && !context.Towns.Any(t => t.Name == value))
{
throw new ArgumentException($"Value {value} not valid.{Environment.NewLine}Town {value} not found!");
}
switch (property)
{
case "Password":
if (!value.Any(Char.IsDigit) || !value.Any(Char.IsLower) || value.Length < 6 || value.Length > 50)
{
throw new ArgumentException($"Value {value} not valid.{Environment.NewLine}Invalid Password");
}
user.Password = value;
break;
case "BornTown":
user.BornTownId = context.Towns.SingleOrDefault(t => t.Name == value).Id;
break;
case "CurrentTown":
user.CurrentTownId = context.Towns.SingleOrDefault(t => t.Name == value).Id;
break;
default: throw new ArgumentException($"Property {property} not supported!");
}
context.SaveChanges();
}
return($"User {username} {property} is {value}.");
}
// AcceptFriend <username1> <username2>
public static string Execute(string[] data)
{
var acceptingUserName = data[1];
var requestingUserName = data[2];
if (data.Length < 3)
{
throw new IndexOutOfRangeException($"Command {data[0]} not valid!");
}
using (var db = new PhotoShareContext())
{
var acceptingUser = db.Users.Include(e => e.FriendsAdded).ThenInclude(fa => fa.Friend).FirstOrDefault(e => e.Username == acceptingUserName);
if (Session.User.Username != acceptingUserName)
{
throw new ArgumentException("Invalid credentials!");
}
if (acceptingUser == null)
{
throw new ArgumentException($"{acceptingUserName} not found!");
}
var requestingUser = db.Users.Include(e => e.FriendsAdded).ThenInclude(fa => fa.Friend).FirstOrDefault(e => e.Username == requestingUserName);
if (requestingUser == null)
{
throw new ArgumentException($"{requestingUserName} not found!");
}
bool alreadyAccepted = acceptingUser.FriendsAdded.Any(u => u.Friend == requestingUser);
bool Added = requestingUser.FriendsAdded.Any(u => u.Friend == acceptingUser);
if (!Added)
{
throw new InvalidOperationException($"{requestingUserName} has not added {acceptingUserName} as a friend");
}
if (alreadyAccepted && Added)
{
throw new InvalidOperationException($"{requestingUserName} is already a friend to {acceptingUserName}");
}
acceptingUser.FriendsAdded.Add(new Friendship
{
User = acceptingUser,
Friend = requestingUser
});
db.SaveChanges();
return($"{acceptingUserName} accepted {requestingUserName} as a friend");
}
}
// CreateAlbum <username> <albumTitle> <BgColor> <tag1> <tag2>...<tagN>
public static string Execute(string[] data)
{
var username = data[0];
var albumTitle = data[1];
var tags = new List <string>();
for (int i = 3; i < data.Length; i++)
{
tags.Add($"#{data[i]}");
}
using (var context = new PhotoShareContext())
{
var user = context.Users.FirstOrDefault(x => x.Username == username);
if (user == null)
{
throw new ArgumentException($"User {data[0]} not found!");
}
if (user.AlbumRoles.Any(x => x.Album.Name == albumTitle))
{
throw new ArgumentException($"Album {albumTitle} exists!");
}
if (!Enum.GetNames(typeof(Color)).Contains(data[2]))
{
throw new ArgumentException($"Color {data[2]} not found!");
}
foreach (var tag in tags)
{
if (!context.Tags.Select(x => x.Name).Any(x => x == $"#{tag}"))
{
throw new ArgumentException($"Invalid tags!");
}
}
var album = new Album()
{
Name = albumTitle,
BackgroundColor = (Color)Enum.Parse(typeof(Color), data[2]),
};
context.Albums.Add(album);
foreach (var tag in tags)
{
Tag foundTag = context.Tags.SingleOrDefault(x => x.Name == tag);
context.AlbumTags.Add(new AlbumTag()
{
Album = album,
Tag = foundTag
});
}
context.SaveChanges();
return($"Album {albumTitle} successfully created!");
}
}
// AddTagTo <albumName> <tag>
public static string Execute(string[] data, Session session)
{
if (!session.IsLoggedIn())
{
throw new InvalidOperationException("Invalid credentials!");
}
string albumName = data[0];
string tagName = data[1].ValidateOrTransform();
using (PhotoShareContext context = new PhotoShareContext())
{
Album album = context.Albums
.Include(a => a.AlbumTags)
.Include(a => a.AlbumRoles)
.ThenInclude(ar => ar.User)
.FirstOrDefault(a => a.Name == albumName);
if (album == null)
{
throw new ArgumentException($"Album {albumName} do not exist!");
}
bool isUserOwner = album.AlbumRoles
.Any(ar => ar.Role == Role.Owner && ar.User.Username == session.User.Username);
if (!isUserOwner)
{
throw new InvalidOperationException("Invalid credentials!");
}
Tag tag = context.Tags
.FirstOrDefault(t => t.Name == tagName);
if (tag == null)
{
throw new ArgumentException($"Tag {tagName} do not exist!");
}
AlbumTag albumTag = new AlbumTag()
{
Album = album,
Tag = tag
};
if (album.AlbumTags.Any(at => at.AlbumId == album.Id && at.TagId == tag.Id))
{
throw new InvalidOperationException($"Tag {tag.Name} is already added to album {album.Name}");
}
album.AlbumTags.Add(albumTag);
context.SaveChanges();
}
return($"Tag {tagName} added to {albumName}!");
}
// ShareAlbum <albumId> <username> <permission>
// For example:
// ShareAlbum 4 dragon321 Owner
// ShareAlbum 4 dragon11 Viewer
public static string Execute(string[] data)
{
if (data.Length != 4)
{
throw new InvalidOperationException($"Command {data[0]} not valid!");
}
int albumId = int.Parse(data[1]);
string username = data[2];
string permissionType = ConvertToTitleCase(data[3].ToLower());
string albumTitle = string.Empty;
using (var context = new PhotoShareContext())
{
var album = context.Albums
.Include(a => a.AlbumRoles)
.FirstOrDefault(a => a.Id == albumId);
if (album == null)
{
throw new ArgumentException($"Album {albumId} not found!");
}
albumTitle = album.Name;
var user = context.Users
.Include(a => a.AlbumRoles)
.FirstOrDefault(u => u.Username == username);
if (user == null)
{
throw new ArgumentException($"User {username} not found!");
}
bool permissionTypeIsValid = Enum.TryParse(permissionType, out Role role);
if (!permissionTypeIsValid)
{
throw new ArgumentException("Permission must be either “Owner” or “Viewer”!");
}
AuthenticationCheck.CheckAlbumOwnership(Session.User.Id, albumId, context);
context.AlbumRoles.Add(
new AlbumRole()
{
AlbumId = albumId,
UserId = user.Id,
Role = role
});
context.SaveChanges();
}
return($"Username {username} added to album {albumTitle} ({permissionType})");
}
public void DeleteUser(string username)
{
using (PhotoShareContext context = new PhotoShareContext())
{
User user = context.Users.FirstOrDefault(u => u.Username == username);
user.IsDeleted = true;
context.SaveChanges();
}
}
private static void ResetDatabase()
{
PhotoShareContext context = new PhotoShareContext();
using (context)
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
}
}
public User CheckUserExistence(string userName, PhotoShareContext context)
{
var user = context.Users.SingleOrDefault(u => u.Username == userName);
if (user == null)
{
throw new ArgumentException($"User with {userName} was not found!");
}
return(user);
}
private static int?GetTownId(PhotoShareContext context, string nulll)
{
var townIDs = context.Towns.Where(x => x.Country == country).Select(x => x.Id).ToArray();
if (townIDs.Length == 0)
{
return(null);
}
return(townIDs[random.Next(1, townIDs.Length)]);
}
public bool isRoleExistingForUser(string username, int albumId, Role role)
{
using (PhotoShareContext context = new PhotoShareContext())
{
return(context.AlbumRoles.Any(ar =>
ar.User.Username == username &&
ar.Album.Id == albumId
));
}
}
// ShareAlbum <albumId> <username> <permission>
// For example:
// ShareAlbum 4 dragon321 Owner
// ShareAlbum 4 dragon11 Viewer
public static string Execute(string[] data)
{
var albumId = int.Parse(data[1]);
var username = data[2];
var permission = data[3];
using (var db = new PhotoShareContext())
{
var album = db.Albums
.Where(x => x.Id == albumId)
.SingleOrDefault();
if (album == null)
{
throw new ArgumentException($"Album with ID:{albumId} not found!");
}
var user = db.Users
.Where(x => x.Username == username)
.FirstOrDefault();
if (user == null)
{
throw new ArgumentException($"User {username} not found!");
}
var role = new Role();
switch (permission.ToLower())
{
case "owner":
role = Role.Owner;
break;
case "viewer":
role = Role.Viewer;
break;
default:
throw new ArgumentException("Permission must be either “Owner” or “Viewer”!");
}
;
var albumRole = new AlbumRole()
{
Album = album,
User = user,
Role = role
};
db.AlbumRoles.Add(albumRole);
db.SaveChanges();
return($"Username {username} added to album {album.Name} ({permission})");
}
}
// AcceptFriend <username1> <username2>
public static string Execute(string[] data)
{
var user1Username = data[0];
var user2Username = data[1];
using (var context = new PhotoShareContext())
{
var user1 = context.Users
.Include(u => u.FriendsAdded)
.ThenInclude(fa => fa.Friend)
.FirstOrDefault(u => u.Username == user1Username);
var user2 = context.Users
.Include(u => u.FriendsAdded)
.ThenInclude(fa => fa.Friend)
.FirstOrDefault(u => u.Username == user2Username);
if (user1 == null)
{
throw new ArgumentException($"{user1Username} not found!");
}
if (user2 == null)
{
throw new ArgumentException($"{user2Username} not found!");
}
var iSUser1HasFriendUser2 = user1.FriendsAdded.Any(u => u.Friend == user2);
var IsUser2HasFriendUser1 = user2.FriendsAdded.Any(u => u.Friend == user1);
if (!iSUser1HasFriendUser2 && IsUser2HasFriendUser1)
{
throw new InvalidOperationException($"{user2Username} is already a friend to {user1Username}");
}
if (iSUser1HasFriendUser2 && !IsUser2HasFriendUser1)
{
throw new InvalidOperationException($"{user2Username} has not added {user1Username} as a friend");
}
//if (!iSUser1HasFriendUser2 && IsUser2HasFriendUser1)
//{
// throw new InvalidOperationException($"{user2Username} has not added {user1Username} as a friend");
//}
user2.FriendsAdded.Add(new Friendship()
{
User = user2,
Friend = user1
});
context.SaveChanges();
return($"{user1Username} accepted {user2Username} as a friend");
}
}
// ShareAlbum <albumId> <username> <permission>
// For example:
// ShareAlbum 4 dragon321 Owner
// ShareAlbum 4 dragon11 Viewer
public override string Execute(string[] data, PhotoShareContext context)
{
int albumId = int.Parse(data[0]);
Album album = context.Albums
.Include(a => a.AlbumRoles)
.SingleOrDefault(a => a.Id == albumId);
if (album == null)
{
throw new ArgumentException($"Album {albumId} not found!");
}
string username = data[1];
User user = context.Users
.SingleOrDefault(u => u.Username.Equals(username));
if (user == null)
{
throw new ArgumentException($"User {username} not found!");
}
bool isPermissionValid = Enum.TryParse(data[2], true, out Role permissionRole);
if (!isPermissionValid)
{
throw new ArgumentException("Permission must be either “Owner” or “Viewer”!");
}
AlbumRole role = new AlbumRole
{
Album = album,
User = user,
Role = permissionRole
};
if (album.AlbumRoles.Any(r => r.UserId == user.UserId && r.AlbumId == album.Id))
{
Role currentRole = album.AlbumRoles.Single(r => r.UserId == user.UserId && r.AlbumId == album.Id).Role;
throw new ArgumentException($"User {username} has already assigned {currentRole.ToString()} role to album {album.Name}.");
}
if (!album.AlbumRoles.Select(r => r.UserId).Contains(Session.User.UserId) ||
album.AlbumRoles.Single(r => r.UserId == Session.User.UserId).Role != Role.Owner)
{
throw new InvalidOperationException("Invalid credentials!");
}
album.AlbumRoles.Add(role);
context.SaveChanges();
return($"Username {user.Username} added to album {album.Name} ({permissionRole.ToString()})");
}
// AddFriend <username1> <username2>
public string Execute(string[] data)
{
if (data.Length != 2)
{
throw new InvalidOperationException("Command AddFriend not valid!");
}
if (Session.LoggedUser == null || data[0] != Session.LoggedUser.Username)
{
throw new InvalidOperationException("Invalid credentials!");
}
using (var context = new PhotoShareContext())
{
var user1 = context.Users
.Include(u => u.FriendsAdded)
.Include(u => u.AddedAsFriendBy)
.SingleOrDefault(u => u.Username == data[0]);
var user2 = context.Users
.Include(u => u.FriendsAdded)
.Include(u => u.AddedAsFriendBy)
.SingleOrDefault(u => u.Username == data[1]);
if (user1 == null || user2 == null || user1.IsDeleted == true || user2.IsDeleted == true)
{
throw new ArgumentException(user1 == null || user1.IsDeleted == true
? $"{data[0]} not found!" : $"{data[1]} not found!");
}
if (user1.Username == user2.Username)
{
throw new InvalidOperationException("Invalid friend request!");
}
if (user1.FriendsAdded.Any(u => u.FriendId == user2.Id) && user2.FriendsAdded.All(u => u.FriendId != user1.Id))
{
throw new InvalidOperationException($"You have already sent a request to {user2.Username}");
}
if (user1.FriendsAdded.Any(u => u.FriendId == user2.Id) && user2.FriendsAdded.Any(u => u.FriendId == user1.Id))
{
throw new InvalidOperationException($"{user2.Username} is already a friend to {user1.Username}");
}
user1.FriendsAdded.Add(new Friendship()
{
User = user1, Friend = user2
});
context.SaveChanges();
}
return($"Friend {data[1]} added to {data[0]}");
}
// AddFriend <username1> <username2>
public static string Execute(string[] data)
{
string reqUsername = data[1];
string addedFriendUsername = data[2];
using (var context = new PhotoShareContext())
{
var loggedUser = IsLogged.IsLoggedIn(context);
var reqUser = context.Users
.Include(u => u.FriendsAdded)
.ThenInclude(fa => fa.Friend)
.FirstOrDefault(u => u.Username == reqUsername);
if (loggedUser != reqUser)
{
throw new InvalidOperationException("Invalid credentials!");
}
if (reqUser == null)
{
throw new ArgumentException($"{reqUsername} not found!");
}
var addedFriend = context.Users
.Include(u => u.FriendsAdded)
.ThenInclude(fa => fa.Friend)
.FirstOrDefault(u => u.Username == addedFriendUsername);
if (addedFriend == null)
{
throw new ArgumentException($"{addedFriendUsername} not found!");
}
bool alreadyAdded = reqUser.FriendsAdded.Any(u => u.Friend == addedFriend);
bool accepted = addedFriend.FriendsAdded.Any(u => u.Friend == reqUser);
if (alreadyAdded && accepted)
{
throw new InvalidOperationException($"{addedFriendUsername} is already a friend to {reqUsername}");
}
if (alreadyAdded && !accepted)
{
throw new InvalidOperationException($"{reqUsername} is already sent invite to {addedFriendUsername}");
}
if (!alreadyAdded && accepted)
{
throw new InvalidOperationException($"{addedFriend} is already sent invite to {reqUser}");
}
reqUser.FriendsAdded.Add(
new Friendship()
{
User = reqUser,
Friend = addedFriend
});
context.SaveChanges();
}
return($"Friend {addedFriendUsername} added to {reqUsername}");
}
// ModifyUser <username> <property> <new value>
// For example:
// ModifyUser <username> Password <NewPassword>
// ModifyUser <username> BornTown <newBornTownName>
// ModifyUser <username> CurrentTown <newCurrentTownName>
// !!! Cannot change username
public string Execute(string[] data)
{
Authorization.Instance.ValidateIsUserLoggedIn();
string userName = data[0];
string property = data[1];
string value = data[2];
if (Authorization.Instance.CurrentUser.Username != userName)
{
throw new InvalidOperationException("You can modify only your profile!");
}
using (PhotoShareContext context = new PhotoShareContext())
{
if (!context.Users.Any(u => u.Username == userName))
{
throw new ArgumentException($"User {userName} not found!");
}
User user = context.Users.FirstOrDefault(u => u.Username == userName);
switch (property)
{
case "Password":
user.Password = value;
context.SaveChanges();
break;
case "BornTown":
if (!context.Towns.Any(t => t.Name == value))
{
throw new ArgumentException($"Value {value} not valid!\nTown {value} not found!");
}
Town town = context.Towns.FirstOrDefault(t => t.Name == value);
user.BornTown = town;
context.SaveChanges();
break;
case "CurrentTown":
if (!context.Towns.Any(t => t.Name == value))
{
throw new ArgumentException($"Value {value} not valid!\nTown {value} not found!");
}
Town town1 = context.Towns.FirstOrDefault(t => t.Name == value);
user.CurrentTown = town1;
context.SaveChanges();
break;
default:
throw new ArgumentException($"Property {property} not supported!");
}
}
return("User " + userName + " " + property + " is " + value + ".");
}
public bool IsAlbumSharedWithUserInRole(int albumId, string username, Role role)
{
using (PhotoShareContext context = new PhotoShareContext())
{
return(context.AlbumRoles
.Any(ar =>
ar.Album.Id == albumId &&
ar.User.Username == username &&
ar.Role == role));
}
}
public void AddTagToAlbum(string albumName, string tagName)
{
using (PhotoShareContext context = new PhotoShareContext())
{
Tag tag = context.Tags.SingleOrDefault(t => t.Name == tagName);
Album album = context.Albums.SingleOrDefault(a => a.Name == albumName);
album.Tags.Add(tag);
context.SaveChanges();
}
}
public bool HasAlbumTag(string albumName, string tagName)
{
using (PhotoShareContext context = new PhotoShareContext())
{
return(context.Albums
.Include("Tags")
.SingleOrDefault(a => a.Name == albumName)
.Tags
.Any(t => t.Name == tagName));
}
}
public bool IsPictureInAlbum(string albumName, string pictureTitle, string pictureFilePath)
{
using (PhotoShareContext context = new PhotoShareContext())
{
return(context.Albums
.Include("Pictures")
.SingleOrDefault(a => a.Name == albumName)
.Pictures
.Any(p => p.Title == pictureTitle && p.Path == pictureFilePath));
}
}
public void ModifyPassword(string username, string password)
{
using (PhotoShareContext context = new PhotoShareContext())
{
var user = context.Users.FirstOrDefault(u => u.Username == username);
user.Password = password;
context.SaveChanges();
}
}
public bool IsFriendToUser(string userUsername, string friendUsername)
{
using (PhotoShareContext context = new PhotoShareContext())
{
User user = context.Users
.Include(u => u.Friends)
.SingleOrDefault(u => u.Username == userUsername);
return(user.Friends.Any(f => f.Username == friendUsername));
}
}
