public static IQueryable<ArtistForAlbum> WhereHasArtistParticipationStatus(this IQueryable<ArtistForAlbum> query, Artist artist, ArtistAlbumParticipationStatus participation) {

			if (participation == ArtistAlbumParticipationStatus.Everything || artist == null)
				return query;

			var musicProducerTypes = new[] {ArtistType.Producer, ArtistType.Circle, ArtistType.OtherGroup};

			if (musicProducerTypes.Contains(artist.ArtistType)) {

				var producerRoles = ArtistRoles.Composer | ArtistRoles.Arranger;

				switch (participation) {
					case ArtistAlbumParticipationStatus.OnlyMainAlbums:
						return query.Where(a => !a.IsSupport && ((a.Roles == ArtistRoles.Default) || ((a.Roles & producerRoles) != ArtistRoles.Default)) && a.Album.ArtistString.Default != ArtistHelper.VariousArtists);
					case ArtistAlbumParticipationStatus.OnlyCollaborations:
						return query.Where(a => a.IsSupport || ((a.Roles != ArtistRoles.Default) && ((a.Roles & producerRoles) == ArtistRoles.Default)) || a.Album.ArtistString.Default == ArtistHelper.VariousArtists);
					default:
						return query;
				}

			} else {

				switch (participation) {
					case ArtistAlbumParticipationStatus.OnlyMainAlbums:
						return query.Where(a => !a.IsSupport);
					case ArtistAlbumParticipationStatus.OnlyCollaborations:
						return query.Where(a => a.IsSupport);
					default:
						return query;
				}
				
			}

		}

        public ArtistWithArchivedVersionsContract(Artist artist, ContentLanguagePreference languagePreference)
            : base(artist, languagePreference)
        {
            ParamIs.NotNull(() => artist);

            ArchivedVersions = artist.ArchivedVersionsManager.Versions.Select(a => new ArchivedArtistVersionContract(a)).ToArray();
        }

        public HomeModule()
        {
            Get["/"] = _ => {
            var allCDs = CD.GetAllCDs();
            return View["index.cshtml", allCDs];
              };
            // view the mainpage, taking all the CDs as model
            Get["/cd/new"] = _ => {
            return View["addCD.cshtml"];
            };
            //if you get CD/new, take to add CD form//
            Post["/cdAdded"] = _ => {
             var newCD = new CD(Request.Form["cd-title"], Request.Form["cd-artist"], Request.Form["cd-year"], Request.Form["cd-cover"]);
             var newArtist = new Artist(Request.Form["cd-artist"]);
             newArtist.AddArtistCD(newCD);
             return View["cdAdded.cshtml", newCD];
               };

               Get["/searchbyartist"] = _ => {
             return View["searchByArtist.cshtml"];
               };

               Post["/searchresults"] = _ => {
            var selectedArtist = Artist.Find(Request.Form["artist-name"]);
            List<CD> resultCDs = selectedArtist.GetAllArtistsCDs();
            return View["searchResults.cshtml", resultCDs];
              };
        }

 public ArtistViewModel(Artist a)
     : base(a)
 {
     artist = a;
     TypeImage = "\xe13d";
     InitLogo(string.Format("artist_{0}.jpg", Id));
 }

        public void AddOwnedArtist_AlreadyAdded()
        {
            var artist = new Artist { Id = 1 };

            user.AddOwnedArtist(artist);
            user.AddOwnedArtist(artist);
        }

   public int AddArtist(ArtistLite al)
   {
       int result = 1;
       Artist a = new Artist();
       a.ArtistName = al.ArtistName;
       a.ArtistEmail = al.Email;
       a.ArtistWebPage = al.WebPage;
       a.ArtistDateEntered = DateTime.Now;


       try
       {

           st.Artists.Add(a);
           st.SaveChanges();
       }
       catch (Exception ex)
       {
           result = 0;
           throw ex;
       }

       return result;
      
   }

        private void addArtistButton_Click(object sender, System.EventArgs e)
        {
            var repository = new CDCatalogRepository();
            var formHelper = new FormHelper();

            if (!formHelper.TextBoxHasContents(addArtistTxtBoxArtistName))
            {
                MessageBox.Show("Please enter an artist name.", "Input validation error");
                addArtistTxtBoxArtistName.Focus();
            }
            else
            {
                var newArtist = addArtistTxtBoxArtistName.Text.Trim();
                var artists = repository.SearchArtistByArtistNameExclusive(newArtist);

                if (artists.Count > 0)
                {
                    MessageBox.Show("You wanted to add " + newArtist + ", but " + artists[0].ArtistName + " already exsists.", "Artist must be unique");
                    addArtistTxtBoxArtistName.Focus();
                }
                else
                {
                    CreatedArtist = repository.CreateArtist(addArtistTxtBoxArtistName.Text.Trim());
                    this.Close();
                }
            }
        }

		public EntryRefWithCommonPropertiesContract(Artist entry, ContentLanguagePreference languagePreference)
			: base(entry, languagePreference) {

			ArtistString = null;
			EntryTypeName = ArtistTypeNames.ResourceManager.GetString(entry.ArtistType.ToString());

		}

		public ArtistForUser(User user, Artist artist)
			: this() {

			User = user;
			Artist = artist;

		}

 public PlayListElems(Artist aid, Album alid, TrackList trid)
 {
     ArtistName = (string)aid.ArtistName;
     AlbumName = (string)alid.AlbumName;
     TrackNum = (string)trid.TrackNum;
     TrackName = (string)trid.TrackName;
 }

		public void SetUp() {

			artist = CreateEntry.Producer(name: "Tripshots");
			repository = new FakeArtistRepository(artist);

			foreach (var name in artist.Names)
				repository.Save(name);

			user = CreateEntry.User(name: "Miku");
			repository.Save(user);
			permissionContext = new FakePermissionContext(user);
			imagePersister = new InMemoryImagePersister();

			queries = new ArtistQueries(repository, permissionContext, new FakeEntryLinkFactory(), imagePersister, MemoryCache.Default);

			newArtistContract = new CreateArtistContract {
				ArtistType = ArtistType.Producer,
				Description = string.Empty,
				Names = new[] {
					new LocalizedStringContract("Tripshots", ContentLanguageSelection.English)
				},
				WebLink = new WebLinkContract("http://tripshots.net/", "Website", WebLinkCategory.Official)
			};

		}

        public Artist Save(Artist artist)
        {
            Artist artistDB = null;
            if (artist == null)
            {
                throw new ArgumentException("Cannot save null artist");
            }
            try
            {
                StartTx();
                if (artist.Id == null)
                {
                    artistDB = artistDao.Persist(artist);
                }
                else
                {
                    artistDB = artistDao.ById(artist.Id);
                    if (artistDB.Deleted)
                    {
                        throw new EntityNotFoundException();
                    }
                    artistDB = artistDao.Update(artist);
                }
                CommitTx();
            }
            catch (Exception e)
            {
                RollbackTx();
                throw e;
            }

            return artistDB;
        }

		public ArtistReport(Artist artist, ArtistReportType reportType, User user, string hostname, string notes)
			: base(user, hostname, notes) {

			Artist = artist;
			ReportType = reportType;

		}

        public IHttpActionResult PutArtist(int id, Artist artist)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != artist.ArtistId)
            {
                return BadRequest();
            }

            //db.Entry(artist).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ArtistExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

		private IArtistWithSupport CreateArtist(ArtistType artistType, string name) {

			var p = new Artist { ArtistType = artistType };
			p.Names.Add(new ArtistName(p, new LocalizedString(name, ContentLanguageSelection.English)));
			return p.AddAlbum(new Album());

		}

        public ActionResult AddArtist(ArtistModel model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    Artist artist = new Artist();
                    artist.ArtistId = model.yearDropDownId;
                    artist.ArtistFirstName = model.FirstName;
                    artist.ArtistLastName = model.LastName;

                    dataService.ArtistService.AddNew(artist);
                    ViewBag.ThankYou = model.FirstName + " " + model.LastName + " has been successfully added.";
                    return View("ThankYou");

                }
                catch (Exception e)
                {
                    ViewBag.ErrorMessage = e.InnerException;
                    return View("Error");

                }
            }
            else
            {
                ViewBag.ErrorMessage = "Invalid Model State";
                return View("Error");
            }
        }

 public PlayListElems(Artist aid, Album alid, TrackList trid)
 {
     artistName = (string)aid.artistName;
     albumName = (string)alid.albumName;
     trackNum = (string)trid.trackNum;
     trackName = (string)trid.trackName;
 }

		public EntryForApiContract(Artist artist, ContentLanguagePreference languagePreference, IEntryThumbPersister thumbPersister, bool ssl, 
			EntryOptionalFields includedFields)
			: this(artist, languagePreference) {

			ArtistType = artist.ArtistType;			
			CreateDate = artist.CreateDate;
			Status = artist.Status;

			if (includedFields.HasFlag(EntryOptionalFields.MainPicture) && artist.Picture != null) {
				MainPicture = new EntryThumbForApiContract(new EntryThumb(artist, artist.PictureMime), thumbPersister, ssl);					
			}

			if (includedFields.HasFlag(EntryOptionalFields.Names)) {
				Names = artist.Names.Select(n => new LocalizedStringContract(n)).ToArray();				
			}

			if (includedFields.HasFlag(EntryOptionalFields.Tags)) {
				Tags = artist.Tags.Usages.Select(u => new TagUsageForApiContract(u)).ToArray();				
			}

			if (includedFields.HasFlag(EntryOptionalFields.WebLinks)) {
				WebLinks = artist.WebLinks.Select(w => new ArchivedWebLinkContract(w)).ToArray();				
			}

		}

        protected void btnSubmit_Click(object sender, EventArgs e)
        {
            ArtistEvent atd = new ArtistEvent();

            atd.EventID = Convert.ToInt32( ddlTourDate.SelectedValue );

            Artist art = new Artist();

            if (ddlArtist1.SelectedValue != unknownValue && !string.IsNullOrEmpty( ddlArtist1.SelectedValue ))
            {
                art = new Artist(ddlArtist1.SelectedValue);
                atd.ArtistID = art.ArtistID;
                atd.RankOrder = 1;
                atd.Create();

                if (ddlArtist2.SelectedValue != unknownValue && !string.IsNullOrEmpty(ddlArtist2.SelectedValue))
                {
                    art = new Artist(ddlArtist2.SelectedValue);
                    atd.ArtistID = art.ArtistID;
                    atd.RankOrder = 2;
                    atd.Create();

                    if (ddlArtist3.SelectedValue != unknownValue && !string.IsNullOrEmpty(ddlArtist3.SelectedValue))
                    {
                        art = new Artist(ddlArtist3.SelectedValue);
                        atd.ArtistID = art.ArtistID;
                        atd.ArtistID = Convert.ToInt32(ddlArtist3.SelectedValue);
                        atd.RankOrder = 3;
                        atd.Create();
                    }

                }

            }
        }

		public void Create() {

			var result = queries.Create(newArtistContract);

			Assert.IsNotNull(result, "result");
			Assert.AreEqual("Tripshots", result.Name, "Name");

			artist = repository.Load(result.Id);

			Assert.IsNotNull(artist, "Artist was saved to repository");
			Assert.AreEqual("Tripshots", artist.DefaultName, "Name");
			Assert.AreEqual(ContentLanguageSelection.English, artist.Names.SortNames.DefaultLanguage, "Default language should be English");
			Assert.AreEqual(1, artist.WebLinks.Count, "Weblinks count");

			var archivedVersion = repository.List<ArchivedArtistVersion>().FirstOrDefault();

			Assert.IsNotNull(archivedVersion, "Archived version was created");
			Assert.AreEqual(artist, archivedVersion.Artist, "Archived version artist");
			Assert.AreEqual(ArtistArchiveReason.Created, archivedVersion.Reason, "Archived version reason");

			var activityEntry = repository.List<ActivityEntry>().FirstOrDefault();

			Assert.IsNotNull(activityEntry, "Activity entry was created");
			Assert.AreEqual(artist, activityEntry.EntryBase, "Activity entry's entry");
			Assert.AreEqual(EntryEditEvent.Created, activityEntry.EditEvent, "Activity entry event type");

		}