コード例 #1
0
        // AddTagTo <albumName> <tag>
        public override string Execute(string[] data, PhotoShareContext context)
        {
            string albumName = data[0];
            string tagText   = data[1].ValidateOrTransform();

            if (!context.Tags.Any(t => t.Name.Equals(tagText, StringComparison.InvariantCultureIgnoreCase)) ||
                !context.Albums.Any(a => a.Name.Equals(albumName)))
            {
                throw new ArgumentException("Either tag or album does not exist!");
            }

            Tag   currentTag   = context.Tags.SingleOrDefault(t => t.Name.Equals(tagText));
            Album currentAlbum = context.Albums.SingleOrDefault(a => a.Name.Equals(albumName));

            AlbumTag currentAlbumTag = new AlbumTag
            {
                Album = currentAlbum,
                Tag   = currentTag
            };

            currentAlbum.AlbumTags.Add(currentAlbumTag);

            try
            {
                context.SaveChanges();
            }
            catch (DbUpdateException)
            {
                throw new ArgumentException($"Tag {tagText} has already been added to \"{albumName}\"!");
            }

            return($"Tag {currentTag.Name} added to {currentAlbum.Name}!");
        }
コード例 #2
0
        private void SeedAlbumTags()
        {
            Console.WriteLine("Add tags to albums...");
            using (var db = new SocialNetworkDbContext())
            {
                var tags   = db.Tags.ToList();
                var albums = db.Albums.ToList();

                for (int i = 0; i < tags.Count; i++)
                {
                    var tag = tags[i];

                    var albumsCount = random.Next(3, 10);
                    for (int j = 0; j < albumsCount; j++)
                    {
                        var album = albums[random.Next(0, albums.Count)];
                        if (tag.Albums.All(a => a.AlbumId != album.Id))
                        {
                            var albumInTag = new AlbumTag {
                                AlbumId = album.Id
                            };

                            tag.Albums.Add(albumInTag);
                            db.SaveChanges();
                        }
                    }
                }
            }
        }
コード例 #3
0
        public string Execute(string[] data)
        {
            if (data.Length < 2)
            {
                throw new ArgumentException("Invalid command!");
            }

            var albumName = data[0];
            var tagName   = data[1];

            var album = this.context.Albums.FirstOrDefault(a => a.Name == albumName);
            var tag   = this.context.Tags.FirstOrDefault(a => a.Name == tagName.ValidateOrTransform());

            if (tag == null || album == null)
            {
                throw new ArgumentException("Either tag or album do not exist!");
            }

            var albumTag = new AlbumTag
            {
                TagId   = tag.Id,
                AlbumId = album.Id
            };

            album.AlbumTags.Add(albumTag);
            this.context.SaveChanges();

            return($"Tag {tagName} added to {albumName} successfully!");
        }
コード例 #4
0
        public string AddTagTo(string albumName, string tagName)
        {
            User user = Session.User;

            CheckCredentials(albumName, user);

            var album = db.Albums
                        .Include(a => a.AlbumTags)
                        .ThenInclude(t => t.Tag)
                        .Include(a => a.AlbumRoles)
                        .FirstOrDefault(a => a.Name == albumName);

            var tag = db.Tags
                      .Include(t => t.AlbumTags)
                      .ThenInclude(a => a.Album)
                      .FirstOrDefault(t => t.Name == tagName);

            CheckAlbumAndTag(albumName, tagName, album, tag);

            var albumTag = new AlbumTag()
            {
                Album = album,
                Tag   = tag
            };

            db.AlbumTags.Add(albumTag);
            album.AlbumTags.Add(albumTag);
            tag.AlbumTags.Add(albumTag);

            db.SaveChanges();



            return($"Tag {tagName} added to {albumName}!");
        }
コード例 #5
0
        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);
        }
コード例 #6
0
        // AddTagTo <albumName> <tag>
        public static string Execute(string[] data)
        {
            if (Session.User == null)
            {
                throw new InvalidOperationException("Invalid credentials!");
            }

            var albumName = data[1];
            var tagName   = "#" + data[2];

            using (var db = new PhotoShareContext())
            {
                var tag = db.Tags.FirstOrDefault(x => x.Name == tagName);

                var album = db.Albums.FirstOrDefault(x => x.Name == albumName);

                if (tag == null || album == null)
                {
                    throw new ArgumentException("Either tag or album do not exist!");
                }

                var albumTags = new AlbumTag()
                {
                    Album = album,
                    Tag   = tag
                };

                album.AlbumTags.Add(albumTags);
                db.SaveChanges();
            }
            return($"Tag {tagName} added to {albumName}!");
        }
コード例 #7
0
        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);
        }
コード例 #8
0
 // AddTagTo <albumName> <tag>
 public static string Execute(string[] data)
 {
     using (PhotoShareContext db = new PhotoShareContext())
     {
         var albumName = data[1];
         var tagName   = data[2];
         if (!db.Albums.Any(a => a.Name == albumName) || !db.Tags.Any(t => t.Name == tagName))
         {
             throw new ArgumentException($"Either tag or album do not exist!");
         }
         Album album = db.Albums
                       .Include(a => a.AlbumTags)
                       .Include(a => a.AlbumRoles)
                       .ThenInclude(ar => ar.User)
                       .FirstOrDefault(a => a.Name == albumName);
         Tag tag = db.Tags
                   .FirstOrDefault(t => t.Name == tagName);
         AlbumTag albumTag = new AlbumTag()
         {
             Album = album,
             Tag   = tag
         };
         db.AlbumTags.Add(albumTag);
         db.SaveChanges();
         return($"Tag {tag} added to {album}!");
     }
     throw new NotImplementedException();
 }
コード例 #9
0
        // AddTagTo <albumName> <tag>
        public string Execute(string[] data)
        {
            if (Session.User == null)
            {
                throw new InvalidOperationException("Invalid credentials!");
            }

            using (PhotoShareContext context = new PhotoShareContext())
            {
                string albumName = data[1];
                string tagName   = data[2];

                if (context.Albums.Any(a => a.Name != albumName) || context.Tags.Any(t => t.Name != tagName))
                {
                    throw new ArgumentException("Either tag or album do not exist!");
                }

                var album = context.Albums.FirstOrDefault(a => a.Name == albumName);
                var tag   = context.Tags.FirstOrDefault(t => t.Name == tagName);

                var albumTag = new AlbumTag()
                {
                    Album = album,
                    Tag   = tag
                };

                album.AlbumTags.Add(albumTag);

                context.SaveChanges();

                return($"Tag{tag} added to {album}!");
            }
        }
コード例 #10
0
        // AddTagTo <albumName> <tag>
        public static string Execute(string[] data)
        {
            var albumName = data[1];
            var tagName   = data[2];

            if (data.Length < 3)
            {
                throw new IndexOutOfRangeException($"Command {data[0]} not valid!");
            }

            if (Session.User == null)
            {
                throw new ArgumentException("Invalid credentials!");
            }

            using (var db = new PhotoShareContext())
            {
                var album = db.Albums.FirstOrDefault(e => e.Name == albumName);
                var tag   = db.Tags.FirstOrDefault(e => e.Name == "#" + tagName);

                if (album == null || tag == null)
                {
                    throw new ArgumentException("Either tag or album do not exist!");
                }

                var albumTag = new AlbumTag()
                {
                    Album = album,
                    Tag   = tag
                };
                db.AlbumTags.Add(albumTag);
                db.SaveChanges();
                return($"Tag {tagName} added to {albumName}!");
            }
        }
コード例 #11
0
        public string AddTagTo(string albumName, string tagName, int userId)
        {
            var album = context.Albums.Include(a => a.AlbumRoles).SingleOrDefault(a => a.Name == albumName);

            var tag = context.Tags.SingleOrDefault(t => t.Name == "#" + tagName);

            if (album == null || tag == null)
            {
                throw new ArgumentException("Either tag or album do not exist!");
            }

            var role = album.AlbumRoles.SingleOrDefault(ar => ar.UserId == userId);

            if (role == null || !role.Role.Equals(Role.Owner))
            {
                throw new InvalidOperationException($"Invalid credentials!");
            }
            var albumTag = new AlbumTag
            {
                Album = album,
                Tag   = tag
            };

            context.AlbumTags.Add(albumTag);

            context.SaveChanges();

            return($"Tag {tagName} added to {albumName}!");
        }
コード例 #12
0
        public Album Create(int userId, string albumTitle, string BgColor, params string[] tags)
        {
            var backgroundColors = Enum.Parse <Color>(BgColor, true);

            Tag[] tagEntities = context.Tags.Where(t => tags.Contains(t.Name)).ToArray();

            Album album = new Album
            {
                Name            = albumTitle,
                BackgroundColor = backgroundColors
            };

            this.context.Albums.Add(album);

            for (int i = 0; i < tagEntities.Count(); i++)
            {
                AlbumTag albumTag = new AlbumTag
                {
                    AlbumId = album.Id,
                    TagId   = tagEntities[i].Id
                };
            }

            this.context.SaveChanges();
            return(album);
        }
コード例 #13
0
        // AddTagTo <albumName> <tag>
        public static string Execute(string[] data)
        {
            var albumName = data[0];
            var tagName   = data[1].ValidateOrTransform();

            using (var context = new PhotoShareContext())
            {
                var tag   = context.Tags.FirstOrDefault(t => t.Name == tagName);
                var album = context.Albums.FirstOrDefault(a => a.Name == albumName);

                if (!(tag != null && album != null))
                {
                    throw new ArgumentException($"Either tag or album do not exist!");
                }

                var albumTag = new AlbumTag()
                {
                    Album = album,
                    Tag   = tag
                };

                context.AlbumTags.Add(albumTag);

                context.SaveChanges();
            }

            return($"Tag {tagName} added to {albumName}!");
        }
コード例 #14
0
        // AddTagTo <albumName> <tag>
        public override string Execute(string[] data)
        {
            if (data.Length < DataLength)
            {
                throw new ArgumentException(string.Format(ErrorMessages.InvalidCommandName, nameof(AddFriendCommand)));
            }

            var albumName = data[1];
            var tagName   = data[2];

            using (var context = new PhotoShareContext())
            {
                if (!context.Albums.Any(a => a.Name == albumName) || !context.Tags.Any(t => t.Name == "#" + tagName))
                {
                    throw new ArgumentException(ErrorMessages.NonExistingTagOrAlbum);
                }

                var album = context.Albums.Single(a => a.Name.Equals(albumName));
                var tag   = context.Tags.Single(t => t.Name.Equals(TagPrefix + tagName));

                var albumTag = new AlbumTag {
                    Album = album, Tag = tag
                };

                context.AlbumTags.Add(albumTag);
                context.SaveChanges();
            }

            return(string.Format(Messages.AddedTagToAlbum, tagName, albumName));
        }
コード例 #15
0
        // AddTagTo <albumName> <tag>

        public string Execute(params string[] args)
        {
            string albumTitle = args[0];
            string tagName    = args[1];

            if (Session.User == null || !Session.User.AlbumRoles.Any(ar => ar.Album.Name == albumTitle))
            {
                throw new InvalidOperationException("Invalid credentials!");
            }

            if (!Checker.AlbumExists(albumTitle) || !Checker.TagsExists(tagName))
            {
                throw new ArgumentException("Either tag or album do not exist!");
            }

            using (var db = new PhotoShareContext())
            {
                Album album = db.Albums.FirstOrDefault(a => a.Name == albumTitle);
                Tag   tag   = db.Tags.FirstOrDefault(t => t.Name == tagName);

                AlbumTag albumTag = new AlbumTag()
                {
                    Album = album,
                    Tag   = tag,
                };

                album.AlbumTags.Add(albumTag);

                db.SaveChanges();
            }

            return($"Tag {tagName} added to {albumTitle}!");
        }
コード例 #16
0
        // AddTagTo <albumName> <tag>
        public static string Execute(string[] data)
        {
            var albumName = data[1];
            var albumTag  = data[2];

            using (var db = new PhotoShareContext())
            {
                var album = db.Albums
                            .Where(x => x.Name == albumName)
                            .SingleOrDefault();

                var tag = db.Tags
                          .Where(x => x.Name == albumTag)
                          .SingleOrDefault();

                if (album == null || tag == null)
                {
                    throw new ArgumentException($"Either tag or album do not exist!");
                }

                var newAlbum = new AlbumTag()
                {
                    Album = album,
                    Tag   = tag
                };

                db.AlbumTags.Add(newAlbum);
                db.SaveChanges();

                return($"Tag #{tag} added to {album}!");
            }
        }
コード例 #17
0
        public Album Create(int userId, string albumTitle, string BgColor, string[] tags)
        {
            var bgColorAsEnum = Enum.Parse <Color>(BgColor);

            var album = new Album
            {
                Name            = albumTitle,
                BackgroundColor = bgColorAsEnum
            };

            this.context.Albums.Add(album);

            foreach (var tag in tags)
            {
                var tagId = this.context.Tags
                            .FirstOrDefault(t => t.Name.Equals(tag)).Id;

                var albumTag = new AlbumTag
                {
                    Album = album,
                    TagId = tagId
                };

                this.context.AlbumTags.Add(albumTag);
            }

            this.context.SaveChanges();

            return(album);
        }
コード例 #18
0
        // AddTagTo <albumName> <tag>
        public static string Execute(string[] data)
        {
            string albumName = data[0];
            string tagName   = TagUtilities.ValidateOrTransform(data[1]);

            using (PhotoShareContext context = new PhotoShareContext())
            {
                Tag   tag   = context.Tags.SingleOrDefault(t => t.Name == tagName);
                Album album = context.Albums.SingleOrDefault(a => a.Name == albumName);

                if (tag == null || album == null)
                {
                    throw new ArgumentException("Either album or tag do not exists!");
                }

                AlbumTag albumTag = new AlbumTag()
                {
                    AlbumId = album.Id,
                    Album   = album,
                    TagId   = tag.Id,
                    Tag     = tag
                };

                if (context.AlbumTags.Any(at => at == albumTag))
                {
                    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}");
        }
コード例 #19
0
        // 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}!");
        }
コード例 #20
0
        public AlbumTag AddTagTo(int albumId, int tagId)
        {
            AlbumTag albumTag = new AlbumTag()
            {
                AlbumId = albumId, TagId = tagId
            };

            this.context.AlbumTags.Add(albumTag);
            this.context.SaveChanges();
            return(albumTag);
        }
コード例 #21
0
        public void AddTagToAlbum(Album album, Tag tag)
        {
            AlbumTag albumTag = new AlbumTag
            {
                Album = album,
                Tag   = tag
            };

            context.AlbumTags.Add(albumTag);

            context.SaveChanges();
        }
コード例 #22
0
        // AddTagTo <albumName> <tag>
        public static string Execute(string[] data)
        {
            string albumName = data[1];
            string tagName   = data[2];

            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(u => u.User)
                            .Where(a => a.Name == albumName)
                            .FirstOrDefault();
                if (album == null)
                {
                    throw new ArgumentException("Either tag or album do not exist!");
                }

                var tag = db.Tags
                          .Where(t => t.Name == "#" + tagName)
                          .FirstOrDefault();
                if (tag == null)
                {
                    throw new ArgumentException("Either tag or album do not exist!");
                }

                //if loggedUser try to add tag to album he doesnt own
                bool isLoggedUserOwnTheAlbum = album.AlbumRoles
                                               .Any(u => u.User.Username == loggedUser.Username && u.Role == Role.Owner);
                if (!isLoggedUserOwnTheAlbum)
                {
                    throw new InvalidOperationException($"Invalid credentials! You cannot add tag to album you don't own.");
                }

                var albumTag = new AlbumTag
                {
                    Album = album,
                    Tag   = tag
                };
                db.AlbumTags.Add(albumTag);
                db.SaveChanges();

                string result = $"Tag {tagName} added to {albumName}!";
                return(result);
            }
        }
コード例 #23
0
ファイル: Program.cs プロジェクト: tanyta78/CSharpWeb
        private static void SeedTags(SocialNetworkDbContext db)
        {
            int totalTags = db.Albums.Count() * 20;

            var validtags = new List <Tag>();

            for (int i = 0; i < totalTags; i++)
            {
                var tag = new Tag
                {
                    Name = TagTransformer.Transform($"tag{i}")
                };

                validtags.Add(tag);
            }

            db.Tags.AddRange(validtags);

            db.SaveChanges();
            Console.WriteLine("Tags created successfully!");

            var albumIds = db.Albums.Select(a => a.Id).ToList();

            foreach (var tag in validtags)
            {
                var totalAlbum = random.Next(0, 20);

                for (int i = 0; i < totalAlbum; i++)
                {
                    var albumId = albumIds[random.Next(0, albumIds.Count)];

                    var tagExistForAlbums = db.Albums
                                            .Any(a => a.Id == albumId && a.Tags.Any(t => t.TagId == tag.Id));

                    if (tagExistForAlbums)
                    {
                        i--;
                        continue;
                    }

                    var albumTag = new AlbumTag()
                    {
                        TagId   = tag.Id,
                        AlbumId = albumId
                    };

                    tag.Albums.Add(albumTag);
                    db.SaveChanges();
                }
                Console.WriteLine("AlbumTags created successfully!");
            }
        }
コード例 #24
0
 public static AlbumTag Get(AlbumTag item)
 {
     try
     {
         using (var db = new Entities(ConnectionStringHelper.ConnectionString()))
         {
             return(db.AlbumTag.Where(r => r.AlbumId == item.AlbumId && r.TagId == item.TagId).FirstOrDefault());
         }
     }
     catch (EntityException e)
     {
         throw e;
     }
 }
        // 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));
        }
コード例 #26
0
        public AlbumTag AddTagTo(int albumId, int tagId)
        {
            var albumTag = new AlbumTag
            {
                AlbumId = albumId,
                TagId   = tagId
            };

            context.AlbumTags.Add(albumTag);

            context.SaveChanges();

            return(albumTag);
        }
コード例 #27
0
        // AddTagTo <albumName> <tag>
        public static string Execute(string[] data)
        {
            string albumName = data[1];
            string tagName   = data[2].ValidateOrTransform();

            using (PhotoShareContext context = new PhotoShareContext())
            {
                var album = context.Albums
                            .Include(x => x.AlbumTags)
                            .Include(x => x.AlbumRoles)
                            .ThenInclude(x => x.User)
                            .Where(x => x.Name == albumName)
                            .FirstOrDefault();

                var tag = context.Tags
                          .Where(x => x.Name == tagName)
                          .FirstOrDefault();

                if (album == null ||
                    tag == null)
                {
                    throw new ArgumentException($"Either tag or album do not exist!");
                }

                if (Session.User == null)
                {
                    throw new InvalidOperationException($"Invalid credentials!");
                }

                bool isOwner = album.AlbumRoles.Any(ar => ar.Role == Role.Owner &&
                                                    ar.User.Username == Session.User.Username);

                if (!isOwner)
                {
                    throw new InvalidOperationException($"Invalid credentials!");
                }

                AlbumTag at = new AlbumTag()
                {
                    Album = album,
                    Tag   = tag
                };

                context.AlbumTags.Add(at);
                context.SaveChanges();
            }

            return($"Tag {tagName} added to {albumName}!");
        }
コード例 #28
0
        public void AddTagToAlbum(string album, string tag)
        {
            Album alb = this.context.Albums.Single(a => a.Name == album);
            Tag   t   = this.context.Tags.Single(tn => tn.Name == tag);

            AlbumTag at = new AlbumTag()
            {
                AlbumId = alb.Id,
                TagId   = t.Id
            };

            this.context.AlbumTags.Add(at);

            this.context.SaveChanges();
        }
コード例 #29
0
 public static int Save(AlbumTag item)
 {
     try
     {
         using (var db = new Entities(ConnectionStringHelper.ConnectionString()))
         {
             db.AlbumTag.Add(item);
             return(db.SaveChanges());
         }
     }
     catch (EntityException e)
     {
         throw e;
     }
 }
コード例 #30
0
        public AlbumTag AddTagTo(int albumId, int tagId)
        {
            AlbumTag albumTag = new AlbumTag()
            {
                AlbumId = albumId,
                TagId   = tagId
            };

            if (!context.AlbumTags.Any(at => at.AlbumId == albumId && at.TagId == tagId))
            {
                context.AlbumTags.Add(albumTag);
            }
            context.SaveChanges();
            return(albumTag);
        }