// ShareAlbum <albumId> <username> <permission>
public string Execute(string[] data)
{
int albumId = int.Parse(data[0]);
AlbumDto albumDTO = albumService.ById <AlbumDto>(albumId);
if (albumDTO == null)
{
throw new ObjectNotFoundException(typeof(Album).Name, data[0]);
}
string username = data[1];
UserRolesDto userDTO = userService.ByUsername <UserRolesDto>(username);
if (userDTO == null || userDTO.IsDeleted == true)
{
throw new ObjectNotFoundException(typeof(User).Name, username);
}
if (!Enum.TryParse(data[2], true, out Role role))
{
throw new InvalidPermissionException();
}
string permission = role.ToString();
AlbumRoleDto alreadySharedAlbum = userDTO.Permissions
.FirstOrDefault(p => p.AlbumName == albumDTO.Name);
if (alreadySharedAlbum != null && alreadySharedAlbum.Permission == permission)
{
throw new PermissionAlreadyGrantedException(username, permission, albumDTO.Name);
}
AlbumRole albumRole = albumRoleService.PublishAlbumRole(albumId, userDTO.Id, permission);
return(String.Format(SuccessMessage, username, albumDTO.Name, permission));
}
public void AddAlbum(string username, string albumTitle, Color color, List <string> tags)
{
using (var context = new PhotoShareContext())
{
var album = new Album()
{
Name = albumTitle,
BackgroundColor = color,
Tags = context.Tags.Where(t => tags.Contains(t.Name)).ToList()
};
User owner = context.Users.SingleOrDefault(u => u.Username == username);
if (owner != null)
{
var albumRole = new AlbumRole()
{
User = owner,
Album = album,
Role = Role.Owner
};
album.AlbumRoles.Add(albumRole);
context.Albums.Add(album);
context.SaveChanges();
}
}
}
//CreateAlbum <username> <albumTitle> <BgColor> <tag1> <tag2>...<tagN>
public override string Execute()
{
string userName = Data[1];
string albumTitle = Data[2];
string bgColor = Data[3];
IEnumerable <Tag> tags = Data.Skip(4).Select(tagName => new Tag()
{
Name = tagName
});
User user = this.unit
.Users
.FirstOrDefaultWhere(u => u.Username.ToLower() == userName.ToLower());
Color backgroundColor = (Color)Enum.Parse(typeof(Color), bgColor);
Album album = new Album()
{
Name = albumTitle,
BackgroundColor = backgroundColor,
Tags = tags.ToArray()
};
AlbumRole role = new AlbumRole()
{
Album = album,
User = user,
Role = Role.Owner
};
user.AlbumRoles.Add(role);
this.unit.Albums.Add(album);
return($"{albumTitle} was added to database");
}
public void ShareAlbum(int albumId, string username, string permission)
{
using (PhotoShareContext context = new PhotoShareContext())
{
var album = context.Albums.FirstOrDefault(a => a.Id == albumId);
var user = context.Users.FirstOrDefault(u => u.Username == username);
Role role = new Role();
if (permission == "Owner")
{
role = Role.Owner;
}
else
{
role = Role.Viewer;
}
AlbumRole albRole = new AlbumRole();
albRole.Album = album;
albRole.User = user;
albRole.Role = role;
context.AlbumRoles.Add(albRole);
context.SaveChanges();
}
}
public Album Create(int userId, string albumName, string backgroundColor, string[] tagNames)
{
Album album = new Album()
{
Name = albumName,
BackgroundColor = Enum.Parse <Color>(backgroundColor, true),
};
context.Albums.Add(album);
context.SaveChanges();
AlbumRole albumRole = new AlbumRole()
{
AlbumId = album.Id,
UserId = userId,
Role = Role.Owner
};
context.AlbumRoles.Add(albumRole);
context.SaveChanges();
foreach (var tagName in tagNames)
{
Tag tag = context.Tags.FirstOrDefault(t => t.Name == tagName);
AlbumTag albumTag = new AlbumTag()
{
AlbumId = album.Id,
TagId = tag.Id
};
context.AlbumTags.Add(albumTag);
}
context.SaveChanges();
return(album);
}
// ShareAlbum <albumId> <username> <permission>
// For example:
// ShareAlbum 4 dragon321 Owner
// ShareAlbum 4 dragon11 Viewer
public string Execute(string[] data)
{
int albumId = int.Parse(data[0]);
string username = data[1];
string inputRole = data[2];
bool roleIsValid = Enum.TryParse(inputRole, out Role role);
if (!roleIsValid)
{
throw new ArgumentException($"Permission must be either “Owner” or “Viewer”!");
}
bool albumExists = this.albumService.Exists(albumId);
if (!albumExists)
{
throw new ArgumentException($"Album {albumId} not found!");
}
bool userExists = this.userService.Exists(username);
if (!userExists)
{
throw new ArgumentException($"User {username} not found!");
}
User user = this.userService.ByUsername <User>(username);
Album album = this.albumService.ById <Album>(albumId);
AlbumRole albumRole = this.albumRoleService.PublishAlbumRole(albumId, user.Id, inputRole);
return($"Username {username} added to album {album.Name} ({role.ToString()})");
}
public AlbumRole PublishAlbumRole(int albumId, int userId, string role)
{
Role roleAsEnum;
try
{
roleAsEnum = Enum.Parse <Role>(role, true);
}
catch
{
throw new ArgumentException(InvalidRole);
}
var albumRole = new AlbumRole()
{
AlbumId = albumId,
UserId = userId,
Role = roleAsEnum
};
this.context.AlbumRoles.Add(albumRole);
this.context.SaveChanges();
return(albumRole);
}
public void AddAlbum(string username, string albumName, Color color, string[] tagNames)
{
using (PhotoShareContext context = new PhotoShareContext())
{
Album album = new Album()
{
Name = albumName,
BackgroundColor = color,
Tags = context.Tags.Where(t => tagNames.Contains(t.Name)).ToList()
};
User owner = context.Users.SingleOrDefault(u => u.Username == username);
AlbumRole albumRole = new AlbumRole()
{
User = owner,
Album = album,
Role = Role.Owner
};
context.AlbumRoles.Add(albumRole); // v.1
//album.AlbumRoles.Add(albumRole); // v.2
//context.Albums.Add(album); // v.2
context.SaveChanges();
}
}
public Album Create(int userId, string albumTitle, Color BgColor, string[] tags)
{
var album = new Album()
{
Name = albumTitle, BackgroundColor = BgColor
};
this.context.Albums.Add(album);
this.context.SaveChanges();
var id = this.context.Albums.Where(e => e.Name == albumTitle).Select(x => x.Id).First();
AlbumTagService albumTagService = new AlbumTagService(this.context);
TagService tagService = new TagService(this.context);
for (int i = 0; i < tags.Length; i++)
{
var currentTag = tagService.ByName <Tag>(tags[i]);
albumTagService.AddTagTo(id, currentTag.Id);
}
AlbumRoleService roleService = new AlbumRoleService(this.context);
AlbumRole albumRole = new AlbumRole()
{
AlbumId = id, UserId = userId
};
this.context.AlbumRoles.Add(albumRole);
this.context.SaveChanges();
return(album);
}
public Album Create(int userId, string albumTitle, string bgColor, string[] tags)
{
var album = new Album
{
Name = albumTitle,
BackgroundColor = Enum.Parse <Color>(bgColor, true)
};
this.context.Albums.Add(album);
this.context.SaveChanges();
var albumRole = new AlbumRole
{
Album = album,
UserId = userId
};
this.context.AlbumRoles.Add(albumRole);
this.context.SaveChanges();
foreach (var tag in tags)
{
var currentTagId = this.context.Tags.FirstOrDefault(x => x.Name == tag).Id;
var albumTag = new AlbumTag
{
Album = album,
TagId = currentTagId
};
this.context.AlbumTags.Add(albumTag);
}
this.context.SaveChanges();
return(album);
}
//ShareAlbum <albumId> <username> <permission>
//For example:
//ShareAlbum 4 dragon321 Owner
//ShareAlbum 4 dragon11 Viewer
public override string Execute()
{
int albumId = int.Parse(Data[1]);
string userName = Data[2];
string permission = Data[3];
Album album = this.unit.Albums.FirstOrDefaultWhere(a => a.Id == albumId);
User user = this.unit.Users.FirstOrDefaultWhere(u => u.Username.ToLower() == userName.ToLower());
Role role = (Role)Enum.Parse(typeof(Role), permission);
if (album == null)
{
throw new ArgumentNullException(nameof(album), "Album with such id dosn`t exist in database");
}
if (user == null)
{
throw new ArgumentNullException(nameof(user), "User with such userName dosn`t exist in database");
}
AlbumRole albumRole = new AlbumRole()
{
Album = album,
User = user,
Role = role
};
this.unit.AlbumRoles.Add(albumRole);
this.unit.Commit();
return($"{userName} is {permission} to album {album.Name}");
}
// 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];
var loggedUser = Session.User;
if (loggedUser == null)
{
throw new InvalidOperationException("Invalid credentials! You have to login first");
}
using (var db = new PhotoShareContext())
{
var album = db.Albums
.Include(a => a.AlbumRoles)
.ThenInclude(a => a.User)
.SingleOrDefault(a => a.Id == albumId);
if (album == null)
{
throw new ArgumentException($"Album {albumId} not found!");
}
var user = db.Users
.SingleOrDefault(u => u.Username == username);
if (user == null)
{
throw new ArgumentException($"User {username} not found!");
}
bool isPermission = Enum.IsDefined(typeof(Role), permission);
if (!isPermission)
{
throw new ArgumentException("Permission must be either “Owner” or “Viewer”!");
}
//if someone who doesnt own the album try to share
bool isLoggedUserOwnTheAlbum = album.AlbumRoles
.Any(u => u.User.Username == Session.User.Username && u.Role == Role.Owner);
if (!isLoggedUserOwnTheAlbum)
{
throw new InvalidOperationException($"Invalid credentials! You cannot share album which you don't own.");
}
var albumRole = new AlbumRole
{
User = user,
Album = album,
Role = Enum.Parse <Role>(permission)
};
db.AlbumRoles.Add(albumRole);
db.SaveChanges();
string result = $"Username {username} added to album {album.Name} ({permission})";
return(result);
}
}
public void CreateAlbum(string username, string albumTitle, string colorStr, string[] tagNames)
{
var users = this.unitOfWork.Users.FindAll(u => u.Username == username);
User user = null;
if (users.Count() == 0)
{
throw new InvalidOperationException("No such user!");
}
else if (users.Count() > 1)
{
throw new InvalidOperationException("More than 1 user with the same name!");
}
user = users.ToArray()[0];
if (User.idOfLoggedUser != user.Id)
{
throw new InvalidOperationException("User " + username + " must be logged in to create an album!");
}
Color color;
try
{
color = (Color)Enum.Parse(typeof(Color), colorStr);
}
catch (Exception)
{
throw new ArgumentException("Invalid color!");
}
var album = new Album()
{
Name = albumTitle, BackgroundColor = color
};
if (tagNames != null)
{
for (int i = 0; i < tagNames.Length; i++)
{
Tag tag = new Tag()
{
Name = tagNames[i]
};
album.Tags.Add(tag);
}
}
Role role = Role.Owner;
var albumRole = new AlbumRole()
{
Album = album, User = user, Role = role
};
this.unitOfWork.AlbumRoles.Add(albumRole);
this.unitOfWork.Save();
}
// CreateAlbum <username> <albumTitle> <BgColor> <tag1> <tag2>...<tagN>
public string Execute(string[] data)
{
string username = data[0];
string albumTitle = data[1];
string backgroundColor = data[2];
string[] tags = data.Skip(3).Select(t => TagUtilities.ValidateOrTransform(t)).ToArray();
User user = GetUserByUserName(username);
if (user == null)
{
throw new ArgumentException($"User {username} not found!");
}
Color color;
bool isColorValid = Enum.TryParse(backgroundColor, out color);
if (!isColorValid)
{
throw new ArgumentException($"Color {color} not found!");
}
if (tags.Any(t => !IsTagExisting(t)))
{
throw new ArgumentException("Invalid tags!");
}
if (IsAlbumExisting(albumTitle))
{
throw new ArgumentException($"Albulm {albumTitle} exist!");
}
using (PhotoShareContext context = new PhotoShareContext())
{
Album album = new Album();
album.Name = albumTitle;
album.BackgroundColor = color;
album.Tags = context.Tags.Where(t => tags.Contains(t.Name)).ToList();
User owner = context.Users.SingleOrDefault(u => u.Username == username);
if (owner != null)
{
AlbumRole albumRole = new AlbumRole();
albumRole.User = owner;
albumRole.Album = album;
albumRole.Role = Role.Owner;
album.AlbumRoles.Add(albumRole);
context.Albums.Add(album);
context.SaveChanges();
}
}
return($"Albulm {albumTitle} successfully created!");
}
// 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})");
}
}
// 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 void AddUserToAlbum(Album album, User user)
{
AlbumRole albumRole = new AlbumRole
{
Album = album,
User = user
};
context.AlbumRoles.Add(albumRole);
}
// 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})");
}
}
// 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()})");
}
// ShareAlbum <albumId> <username> <permission>
// For example:
// ShareAlbum 4 dragon321 Owner
// ShareAlbum 4 dragon11 Viewer
public static string Execute(params string[] data)
{
var albumId = int.Parse(data[0]);
var username = data[1];
var permission = data[2];
using (var context = new PhotoShareContext())
{
var albumIdParam = context.Albums
.Include(u => u.AlbumRoles)
.FirstOrDefault(a => a.Id == albumId);
if (albumIdParam == null)
{
throw new ArgumentException($"Album {albumId} not found!");
}
var user = context.Users.FirstOrDefault(u => u.Username == username);
if (user == null)
{
throw new ArgumentException($"User {username} not found!");
}
if (permission != "Owner" && permission != "Viewer")
{
throw new ArgumentException("Permission must be either “Owner” or “Viewer”!");
}
var album = context.Albums.FirstOrDefault(a => a.Id == albumId);
Role role = new Role();
if (permission == "Owner")
{
role = Role.Owner;
}
else
{
role = Role.Viewer;
}
AlbumRole albRole = new AlbumRole();
albRole.Album = album;
albRole.User = user;
albRole.Role = role;
context.AlbumRoles.Add(albRole);
context.SaveChanges();
return($"Username {user.Username} added to album {albumIdParam.Name} ({permission})");
}
}
public bool UserIsOwner(int albumId, string username)
{
int userId = this.context.Users.Single(i => i.Username == username).Id;
AlbumRole role = this.context.AlbumRoles.Single(id => id.AlbumId == albumId && id.UserId == userId);
if (role.Role == Role.Owner)
{
return(true);
}
return(false);
}
public AlbumRole PublishAlbumRole(int albumId, int userId, string role)
{
AlbumRole albumRole = new AlbumRole()
{
AlbumId = albumId,
UserId = userId,
Role = Enum.Parse <Role>(role, true)
};
context.AlbumRoles.Add(albumRole);
context.SaveChanges();
return(albumRole);
}
// ShareAlbum <albumId> <username> <permission>
// For example:
// ShareAlbum 4 dragon321 Owner
// ShareAlbum 4 dragon11 Viewer
public string Execute(params string[] data)
{
if (data.Length != 3)
{
throw new InvalidOperationException($"Command ShareAlbum not valid!");
}
int albumId = int.Parse(data[0]);
string albumName = string.Empty;
string username = data[1];
string permission = data[2];
using (var context = new PhotoShareContext())
{
var album = context.Albums
.FirstOrDefault(a => a.Id == albumId);
if (album == null)
{
throw new ArgumentException($"Album {albumId} not found!");
}
albumName = album.Name;
var user = context.Users
.FirstOrDefault(u => u.Username == username);
if (user == null)
{
throw new ArgumentException($"User {user} not found!");
}
if (album.AlbumRoles.FirstOrDefault(ar => ar.User.Username == Data.CurrentUser.Username && ar.Role == Role.Owner) == null)
{
throw new InvalidOperationException("Invalid Credentials!");
}
if (permission != "Owner" && permission != "Viewer")
{
throw new ArgumentException("Permission must be either \"Owner\" or \"Viewer\"!");
}
var albumRole = new AlbumRole();
albumRole.Album = album;
albumRole.User = user;
albumRole.Role = (Role)Enum.Parse(typeof(Role), permission);
context.AlbumRoles.Add(albumRole);
album.AlbumRoles.Add(albumRole);
context.SaveChanges();
}
return($"Username {username} added to album {albumName} ({permission})");
}
// ShareAlbum <albumId> <username> <permission>
// For example:
// ShareAlbum 4 dragon321 Owner
// ShareAlbum 4 dragon11 Viewer
public string Execute(string[] data)
{
Authorization.Instance.ValidateIsUserLoggedIn();
int albumId = int.Parse(data[0]);
string username = data[1];
Role role = Role.Viewer;
try
{
role = (Role)Enum.Parse(typeof(Role), data[2]);
}
catch
{
throw new ArgumentException("Permission must be either “Owner” or “Viewer”!");
}
using (PhotoShareContext context = new PhotoShareContext())
{
if (!context.Albums.Any(a => a.Id == albumId))
{
throw new ArgumentException($"Album {albumId} not found!");
}
if (!context.Users.Any(u => u.Username == username))
{
throw new ArgumentException($"User {username} not found!");
}
Album album = context.Albums.FirstOrDefault(a => a.Id == albumId);
string usernameLogged = Authorization.Instance.CurrentUser.Username;
if (!album.AlbumRoles.Any(ar => ar.User.Username == usernameLogged && ar.Role == Role.Owner))
{
throw new InvalidOperationException("Invalid credentials!");
}
User user = context.Users.FirstOrDefault(u => u.Username == username);
AlbumRole albumRole = new AlbumRole();
albumRole.Album = album;
albumRole.User = user;
albumRole.Role = role;
album.AlbumRoles.Add(albumRole);
context.SaveChanges();
}
return($"Username {username} added to album {albumId} ({role})");
}
// AddTagTo <album> <tag>
public string Execute(string[] arguments)
{
Check.CheckLength(2, arguments);
Authentication.Authorize();;
string albumName = arguments[0];
string tagName = arguments[1];
User currentUser = Authentication.GetCurrentUser();
PhotoShareContext dbContext = new PhotoShareContext();
Album album = dbContext
.Albums
.FirstOrDefault(a => a.Name == albumName);
Tag tag = dbContext
.Tags
.FirstOrDefault(t => t.Name == $"#{tagName}");
if (album == null || tag == null)
{
throw new ArgumentException(Constants.AlbumOrTagDoNotExist);
}
if (Helper.IsAlbumTagExist(dbContext, albumName, tagName))
{
throw new ArgumentException(Constants.AlbumOrTagDoNotExist);
}
AlbumRole albumRole = dbContext
.AlbumRoles
.FirstOrDefault(ar => ar.AlbumId == album.Id && ar.UserId == currentUser.Id);
if (albumRole == null)
{
throw new ArgumentException(Constants.NotUploadPicture);
}
using (dbContext)
{
AlbumTag albumTag = new AlbumTag()
{
AlbumId = album.Id,
TagId = tag.Id
};
dbContext.AlbumTags.Add(albumTag);
dbContext.SaveChanges();
}
return(string.Format(Constants.AddTagToAlbum, tagName, albumName));
}
private void CreateAndAddAlbumRole(User user, Album album)
{
var albumRole = new AlbumRole
{
Album = album,
User = user,
Role = Role.Owner
};
this.db.AlbumRoles.Add(albumRole);
album.AlbumRoles.Add(albumRole);
this.db.SaveChanges();
}
public void ShareAlbum(int albumId, string username, Role role)
{
using (PhotoShareContext context = new PhotoShareContext())
{
AlbumRole albumRole = new AlbumRole()
{
Album = context.Albums.SingleOrDefault(a => a.Id == albumId),
User = context.Users.SingleOrDefault(u => u.Username == username),
Role = role
};
context.AlbumRoles.Add(albumRole);
context.SaveChanges();
}
}
public AlbumRole PublishAlbumRole(int albumId, int userId, Role role)
{
var albumRole = new AlbumRole()
{
AlbumId = albumId,
UserId = userId,
Role = role
};
this.context.AlbumRoles.Add(albumRole);
this.context.SaveChanges();
return(albumRole);
}
public AlbumRole ShareAlbum(Album album, User user, Role role)
{
AlbumRole albumRole = new AlbumRole
{
Album = album,
User = user,
Role = role
};
context.AlbumRoles.Add(albumRole);
context.SaveChanges();
return(albumRole);
}
public AlbumRole PublishAlbumRole(int albumId, int userId, string role)
{
Role roleAsEnum = Enum.Parse <Role>(role);
var albumRole = new AlbumRole()
{
AlbumId = albumId,
UserId = userId,
Role = roleAsEnum
};
this.context.AlbumRoles.Add(albumRole);
this.context.SaveChanges();
return(albumRole);
}
