public ActionResult CreateAlbum(int id)
        {
            var user = LogicProvider.userLogic.GetById(id);
            var Id   = LogicProvider.userLogic.GetByEmail(User.Identity.Name).UserId;

            if (User.Identity.Name == user.Email)
            {
                CreateAlbumVM newAlbum = new CreateAlbumVM("", "", id);
                return(View(newAlbum));
            }
            return(RedirectToAction("UserPage", "User", new { id = Id }));
        }
示例#2
0
        public ActionResult Add()
        {
            CreateAlbumVM album = new CreateAlbumVM();

            album.ProducerList = new List <ProducerVM>();
            album.ArtistList   = new List <ArtistVM>();

            album.Producers = new SelectList(db.Producers.ToList(), "Id", "Name");
            album.Artists   = new SelectList(db.Artists.ToList(), "Id", "Name");
            ProducerVM producer = new ProducerVM {
                Name = "", Studio = "", DateOfBirth = DateTime.Now
            };
            ArtistVM artist = new ArtistVM {
                BirthDate = DateTime.Now, Email = ""
            };

            album.ProducerList.Add(producer);
            album.ArtistList.Add(artist);
            return(View(album));
        }
 public ActionResult CreateAlbum(CreateAlbumVM newAlbum)
 {
     LogicProvider.albumLogic.Add(new Album(newAlbum.Name, newAlbum.Description, newAlbum.UserId));
     return(RedirectToAction("UserPage", "User", new { id = newAlbum.UserId }));
 }
示例#4
0
        public ActionResult Add(CreateAlbumVM album, HttpPostedFileBase CoverImage)
        {
            album.Producers = new SelectList(db.Producers.ToList(), "Id", "Name");
            album.Artists   = new SelectList(db.Artists.ToList(), "Id", "Name");
            if (ModelState.IsValid)
            {
                List <int> artistIds = album.ArtistIds != null?album.ArtistIds.ToList() : new List <int>();

                List <int> producerIds = album.ProducerIds != null?album.ProducerIds.ToList() : new List <int>();

                if (String.IsNullOrEmpty(album.ArtistList[0].Name) && artistIds.Count() == 0)
                {
                    ModelState.AddModelError("", "No Artist Selected");
                    return(View(album));
                }

                if (String.IsNullOrEmpty(album.ProducerList[0].Name) && producerIds.Count() == 0)
                {
                    ModelState.AddModelError("", "No Producers Selected");
                    return(View(album));
                }

                foreach (var item in album.ArtistList)
                {
                    if (!String.IsNullOrEmpty(item.Name))
                    {
                        Artist artist = new Artist
                        {
                            BirthDate   = item.BirthDate,
                            Email       = item.Email,
                            Gender      = item.Gender,
                            Name        = item.Name,
                            PhoneNumber = item.PhoneNumber
                        };
                        if (!db.Artists.Any(m => m.Email == item.Email && m.Name == item.Name))
                        {
                            db.Artists.Add(artist);
                            db.SaveChanges();
                            artistIds.Add(artist.Id);
                        }
                        else
                        {
                            artist = db.Artists.FirstOrDefault(m => m.Email == item.Email && m.Name == item.Name);
                            artistIds.Add(artist.Id);
                        }
                    }
                }



                foreach (var item in album.ProducerList)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        Producer producer = new Producer
                        {
                            DateOfBirth = item.DateOfBirth,
                            Name        = item.Name,
                            Studio      = item.Studio
                        };
                        if (!db.Producers.Any(m => m.DateOfBirth == item.DateOfBirth && m.Name == item.Name && m.Studio == item.Studio))
                        {
                            db.Producers.Add(producer);
                            db.SaveChanges();
                            producerIds.Add(producer.Id);
                        }
                        else
                        {
                            producer = db.Producers.FirstOrDefault(m => m.DateOfBirth == item.DateOfBirth && m.Name == item.Name && m.Studio == item.Studio);
                            producerIds.Add(producer.Id);
                        }
                    }
                }


                if (producerIds.Count() == 0 || artistIds.Count() == 0)
                {
                    ModelState.AddModelError("", "No Artist or Producers");
                    return(View(album));
                }

                Albums albums = new Albums
                {
                    Producers      = db.Producers.Where(m => producerIds.Contains(m.Id)).ToList(),
                    Artists        = db.Artists.Where(m => artistIds.Contains(m.Id)).ToList(),
                    Length         = album.Length,
                    Name           = album.Name,
                    ReleaseDate    = album.ReleaseDate,
                    StudioName     = album.StudioName,
                    IsAgeBar       = album.IsAgeBar,
                    FinePerDay     = album.FinePerDay,
                    CopyNumber     = album.CopyNumber,
                    CoverImagePath = "~/Images/Albums/"
                };

                Albums prevAlbum = db.Albums.Include(m => m.Artists).Include(m => m.Producers)
                                   .FirstOrDefault(m => m.Name == albums.Name);

                bool Status = db.Albums.Include(m => m.Artists).Include(m => m.Producers)
                              .Any(m => m.Name == albums.Name);

                if (Status)
                {
                    if (albums.Producers.Intersect(prevAlbum.Producers) == null && albums.Artists.Intersect(prevAlbum.Artists) == null)
                    {
                        db.Albums.Add(albums);
                        db.SaveChanges();

                        if (!Directory.Exists(Server.MapPath("~/Images/Albums")))
                        {
                            Directory.CreateDirectory(Server.MapPath("~/Images/Albums"));
                        }

                        if (CoverImage.ContentLength > 0)
                        {
                            CoverImage.SaveAs(Server.MapPath("~/Images/Albums/" + albums.id + ".jpg"));
                        }
                        return(RedirectToAction("Index"));
                    }
                    else
                    {
                        ModelState.AddModelError("", "Album Already Exists");
                        return(View(album));
                    }
                }
                else
                {
                    db.Albums.Add(albums);
                    db.SaveChanges();

                    if (!Directory.Exists(Server.MapPath("~/Images/Albums")))
                    {
                        Directory.CreateDirectory(Server.MapPath("~/Images/Albums"));
                    }

                    if (CoverImage.ContentLength > 0)
                    {
                        CoverImage.SaveAs(Server.MapPath("~/Images/Albums/" + albums.id + ".jpg"));
                    }
                    return(RedirectToAction("Index"));
                }
            }
            return(View(album));
        }