private void InitializeData(object sender, EventArgs e)
{
MusicAlbumsGuideDB context = new MusicAlbumsGuideDB();
genres = context.Genres.ToList();
InitializeComboBox(GenreComboBox, new List <object>(genres));
albums = context.Albums.ToList();
List <string> years = new List <string>();
foreach (var album in albums)
{
years.Add(album.ReleaseYear.ToString());
}
InitializeTextBox(ReleaseYearTextBox, new List <object>(years));
carriers = context.Carriers.ToList();
InitializeComboBox(CarrierComboBox, new List <object>(carriers));
types = context.Types.ToList();
InitializeComboBox(TypeComboBox, new List <object>(types));
authors = context.Authors.ToList();
InitializeTextBox(AuthorTextBox, new List <object>(authors));
List <string> trackCounts = new List <string>();
foreach (var album in albums)
{
trackCounts.Add(album.TrackCount.ToString());
}
InitializeTextBox(TrackCountTextBox, new List <object>(trackCounts));
releasingLabels = context.ReleasingLabels.ToList();
InitializeTextBox(ReleaseLabelTextBox, new List <object>(releasingLabels));
}
private void SearchButton_Click(object sender, EventArgs e)
{
if (SearchTextBox.Text == "Введите ключевые слова для поиска")
{
errorProvider1.SetError(SearchTextBox, "Нужно заполнить поле для поиска!");
return;
}
string[] words = SearchTextBox.Text.Split(' ');
MusicAlbumsGuideDB context = new MusicAlbumsGuideDB();
List <Album> allAlbums = context.Albums.Include(p => p.Author).Include(p => p.Carrier).Include(p => p.Genre).Include(p => p.ReleasingLabel).Include(p => p.Type).ToList();
List <Album> findedAlbums = new List <Album>();
List <Album> result = new List <Album>();
foreach (string s in words)
{
findedAlbums = allAlbums.Where(p => (p.Genre.Name == s) || (p.Genre.Name.Contains(s)) || (p.Name == s) || (p.Name.Contains(s)) || (p.Author.Name == s) || (p.Author.Name.Contains(s)) ||
(p.Carrier.Name == s) || (p.Carrier.Name.Contains(s)) || (p.ReleaseYear.ToString() == s) || (p.ReleaseYear.ToString().Contains(s)) || (p.ReleasingLabel.Name == s) || (p.ReleasingLabel.Name.Contains(s)) ||
(p.TrackCount.ToString() == s) || (p.TrackCount.ToString().Contains(s)) || (p.Type.Name == s) || (p.Type.Name.Contains(s))).ToList();
foreach (Album a in findedAlbums)
{
if (result.Contains(a))
{
continue;
}
result.Add(a);
}
}
InitializeAlbumsPreview(result);
}
private void SaveToDatabase()
{
MusicAlbumsGuideDB context = new MusicAlbumsGuideDB();
Album newAlbum = new Album();
newAlbum.Name = NameTextBox.Text;
Genre currentGenre = context.Genres.Where(p => p.Name == GenreComboBox.Text).Single();
newAlbum.GenreId = currentGenre.GenreId;
newAlbum.ReleaseYear = Convert.ToInt32(ReleaseYearTextBox.Text);
Carrier currentCarrier = context.Carriers.Where(p => p.Name == CarrierComboBox.Text).Single();
newAlbum.CarrierId = currentCarrier.CarrierId;
//
Database.Models.Type currentType = context.Types.Where(p => p.Name == TypeComboBox.Text).Single();
newAlbum.TypeId = currentType.TypeId;
Author author;
try
{
author = context.Authors.Where(p => p.Name == AuthorTextBox.Text).Single();
}
catch (Exception)
{
context.Authors.Add(new Author()
{
Name = AuthorTextBox.Text
});
context.SaveChanges();
author = context.Authors.Where(p => p.Name == AuthorTextBox.Text).Single();
}
newAlbum.AuthorId = author.AuthorId;
newAlbum.TrackCount = Convert.ToInt32(TrackCountTextBox.Text);
//
ReleasingLabel releasingLabel;
try
{
releasingLabel = context.ReleasingLabels.Where(p => p.Name == ReleaseLabelTextBox.Text).Single();
}
catch (Exception)
{
context.ReleasingLabels.Add(new ReleasingLabel()
{
Name = ReleaseLabelTextBox.Text
});
context.SaveChanges();
releasingLabel = context.ReleasingLabels.Where(p => p.Name == ReleaseLabelTextBox.Text).Single();
}
newAlbum.ReleasingLabelId = releasingLabel.ReleasingLabelId;
newAlbum.CoverPhoto = ImageMethods.ConvertImageToByteArray(CoverAlbum.Image);
context.Albums.Add(newAlbum);
context.SaveChanges();
}
static public bool isAuthorsTableEmpty(MusicAlbumsGuideDB context)
{
if (!context.Database.Exists())
{
context.Database.Create(); return(true);
}
if (context.Authors.ToList().Count == 0)
{
return(true);
}
return(false);
}
static public bool isDatabaseEmpty(this MusicAlbumsGuideDB context)
{
if (!context.Database.Exists())
{
context.Database.Create(); return(true);
}
if (isAlbumsTableEmpty(context) && isCarriersTableEmpty(context) && isGenresTableEmpty(context) && isTypesTableEmpty(context) && isAuthorsTableEmpty(context))
{
return(true);
}
return(false);
}
public void FilterForm_Load(object sender, EventArgs e)
{
WindowSizeChanged(sender, e);
//
//
this.Location = new Point((parentForm.Location.X + parentForm.Size.Width / 2) - this.Size.Width / 2, (parentForm.Location.Y + parentForm.Size.Height / 2) - this.Size.Height / 2);
this.Anchor = AnchorStyles.None;
//
GenresComboBox.Items.Clear();
ReleaseYearsComboBox.Items.Clear();
CarriersComboBox.Items.Clear();
TypesComboBox.Items.Clear();
AuthorsComboBox.Items.Clear();
TracksCountComboBox.Items.Clear();
ReleasingLabelsComboBox.Items.Clear();
//
this.StartPosition = FormStartPosition.CenterParent;
ControlsChangeMethods.RoundBorderForm(this);
MusicAlbumsGuideDB context = new MusicAlbumsGuideDB();
List <Genre> genres = context.Genres.ToList();
GenresComboBox.InitializeItems(new List <object>(genres));
List <Album> albums = context.Albums.OrderBy(p => p.ReleaseYear).ToList();
List <string> years = new List <string>();
foreach (var album in albums)
{
years.Add(album.ReleaseYear.ToString());
}
ReleaseYearsComboBox.InitializeItems(new List <object>(years));
List <Carrier> carriers = context.Carriers.ToList();
CarriersComboBox.InitializeItems(new List <object>(carriers));
List <Database.Models.Type> types = context.Types.ToList();
TypesComboBox.InitializeItems(new List <object>(types));
List <Author> authors = context.Authors.ToList();
AuthorsComboBox.InitializeItems(new List <object>(authors));
albums = albums.OrderBy(p => p.TrackCount).ToList();
List <string> trackCounts = new List <string>();
foreach (var album in albums)
{
trackCounts.Add(album.TrackCount.ToString());
}
TracksCountComboBox.InitializeItems(new List <object>(trackCounts));
List <ReleasingLabel> labels = context.ReleasingLabels.ToList();
ReleasingLabelsComboBox.InitializeItems(new List <object>(labels));
Show();
}
private void EnterDataFromAlbum(int AlbumId)
{
MusicAlbumsGuideDB context = new MusicAlbumsGuideDB();
Album current = context.Albums.Include(p => p.Author).Include(p => p.Carrier).Include(p => p.Genre).Include(p => p.Type).Include(p => p.ReleasingLabel).Where(p => p.AlbumId == AlbumId).Single();
CoverAlbum.Image = ImageMethods.ConvertByteArrayToImage(current.CoverPhoto);
CoverAlbum.SizeMode = PictureBoxSizeMode.StretchImage;
NameTextBox.Text = current.Name;
GenreComboBox.Text = current.Genre.Name;
ReleaseYearTextBox.Text = current.ReleaseYear.ToString();
CarrierComboBox.Text = current.Carrier.Name;
TypeComboBox.Text = current.Type.Name;
AuthorTextBox.Text = current.Author.Name;
TrackCountTextBox.Text = current.TrackCount.ToString();
ReleaseLabelTextBox.Text = current.ReleasingLabel.Name;
}
private void Delete_Click(object sender, EventArgs e)
{
MusicAlbumsGuideDB context = new MusicAlbumsGuideDB();
Album albumToDelete = context.Albums.Include(p => p.ReleasingLabel).Include(p => p.Author).Include(p => p.Carrier).Include(p => p.Genre).Include(p => p.Type).Where(p => p.AlbumId == currentAlbum.AlbumId).Single();
ReleasingLabel currentReleasingLabel = albumToDelete.ReleasingLabel;
string labelName = "";
string authName = "";
if (currentReleasingLabel != null)
{
if (context.Albums.Where(p => p.ReleasingLabel.ReleasingLabelId == currentReleasingLabel.ReleasingLabelId).ToList().Count == 1)
{
labelName = albumToDelete.ReleasingLabel.Name;
}
}
//
Author currentAuth = albumToDelete.Author;
if (currentAuth != null)
{
if (context.Albums.Where(p => p.Author.AuthorId == currentAuth.AuthorId).ToList().Count == 1)
{
authName = currentAuth.Name;
}
}
//
context.Albums.Remove(albumToDelete);
context.SaveChanges();
if (labelName != "")
{
context.ReleasingLabels.Remove(context.ReleasingLabels.Where(p => p.Name == labelName).Single());
}
context.SaveChanges();
if (authName != "")
{
context.Authors.Remove(context.Authors.Where(p => p.Name == authName).Single());
}
context.SaveChanges();
parentForm.HomeButton.PerformClick();
}
static public Album GetFullAlbum(int AlbumId)
{
MusicAlbumsGuideDB context = new MusicAlbumsGuideDB();
return(context.Albums.Include(p => p.Author).Include(p => p.Carrier).Include(p => p.Genre).Include(p => p.ReleasingLabel).Include(p => p.Type).Where(p => p.AlbumId == AlbumId).Single());
}
protected override void Seed(MusicAlbumsGuideDB context)
{
//List<Lot> lots = new List<Lot>() { new Lot { Name = "Мультиварка Bosch", State = "б/у", StartDate = DateTime.Now, FinishDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day + 2) } };
//for (int i = 0; i < lots.Count; i++)
//{
// context.Lots.Add(lots[i]);
//}
//context.SaveChanges();
List <Carrier> carriers = new List <Carrier>()
{
new Carrier()
{
Name = "Винил"
},
new Carrier()
{
Name = "Аудиокассеты"
},
new Carrier()
{
Name = "Цифровой носитель"
},
new Carrier()
{
Name = "CD диск"
}
};
for (int i = 0; i < carriers.Count; i++)
{
context.Carriers.Add(carriers[i]);
}
context.SaveChanges();
List <Genre> genres = new List <Genre>()
{
new Genre()
{
Name = "oldschool rap"
},
new Genre()
{
Name = "newschool rap"
},
new Genre()
{
Name = "gangsta rap"
},
new Genre()
{
Name = "horrorcore"
},
new Genre()
{
Name = "south hip-hop"
},
new Genre()
{
Name = "rock"
},
new Genre()
{
Name = "punk-rock"
},
new Genre()
{
Name = "hardcore"
},
new Genre()
{
Name = "post-hardcore"
},
new Genre()
{
Name = "metalcore"
},
new Genre()
{
Name = "emo"
},
new Genre()
{
Name = "screamo"
},
new Genre()
{
Name = "punk"
},
new Genre()
{
Name = "post-punk"
},
new Genre()
{
Name = "metal"
},
new Genre()
{
Name = "nu-metal"
},
new Genre()
{
Name = "heavy metal"
},
new Genre()
{
Name = "trash metal"
},
new Genre()
{
Name = "black metal"
},
new Genre()
{
Name = "death metal"
},
new Genre()
{
Name = "slamming brutal death"
},
new Genre()
{
Name = "funeral doom"
},
new Genre()
{
Name = "doom metal"
},
new Genre()
{
Name = "EDM"
},
new Genre()
{
Name = "techno"
},
new Genre()
{
Name = "house"
},
new Genre()
{
Name = "tranсe"
},
new Genre()
{
Name = "synthpop"
},
new Genre()
{
Name = "ambient"
},
new Genre()
{
Name = "noise"
},
new Genre()
{
Name = "noise-rock"
},
new Genre()
{
Name = "powernoise"
},
new Genre()
{
Name = "harsh noise"
},
new Genre()
{
Name = "classic"
},
new Genre()
{
Name = "jazz"
},
new Genre()
{
Name = "blues"
},
};
for (int i = 0; i < genres.Count; i++)
{
context.Genres.Add(genres[i]);
}
context.SaveChanges();
List <Models.Type> types = new List <Models.Type>()
{
new Models.Type()
{
Name = "Полноформатный"
},
new Models.Type()
{
Name = "EP"
},
new Models.Type()
{
Name = "Сингл"
},
new Models.Type()
{
Name = "Демо"
},
new Models.Type()
{
Name = "Сплит"
}
};
for (int i = 0; i < types.Count; i++)
{
context.Types.Add(types[i]);
}
context.SaveChanges();
context.SaveChanges();
}
private bool ValidateForm()
{
bool result = true;
MusicAlbumsGuideDB context = new MusicAlbumsGuideDB();
if (string.IsNullOrEmpty(NameTextBox.Text) || NameTextBox.Text == "Введите имя альбома" || NameTextBox.Text == " ")
{
NameErrorProvider.SetError(NameTextBox, "Поле имени должно быть заполнено");
if (result == true)
{
result = false;
}
}
else
{
if (NameTextBox.Text.Length > 40)
{
NameErrorProvider.SetError(NameTextBox, "Слишком длинное имя альбома");
if (result == true)
{
result = false;
}
}
else
{
NameErrorProvider.Clear();
}
}
List <Album> albums = context.Albums.Include(p => p.Author).ToList();
List <string> names = new List <string>();
foreach (var album in albums)
{
names.Add(album.Name);
}
if (string.IsNullOrEmpty(GenreComboBox.Text) || GenreComboBox.Text == "Выберите жанр альбома" || GenreComboBox.Text == " ")
{
GenreErrorProvider.SetError(GenreComboBox, "Поле жанра должно быть заполнено");
if (result == true)
{
result = false;
}
}
else
{
GenreErrorProvider.Clear();
}
if (string.IsNullOrEmpty(AuthorTextBox.Text) || AuthorTextBox.Text == "Введите автора альбома" || AuthorTextBox.Text == " ")
{
AuthorErrorProvider.SetError(AuthorTextBox, "Поле автора должно быть заполнено");
if (result == true)
{
result = false;
}
}
if (names.Contains(NameTextBox.Text))
{
List <Album> find = albums.Where(p => p.Name == NameTextBox.Text && p.Author.Name == AuthorTextBox.Name).ToList();
if (find.Count != 0)
{
AuthorErrorProvider.SetError(NameTextBox, "Альбом с таким именем у данного автора уже существует");
}
if (result == true)
{
result = false;
}
}
else
{
AuthorErrorProvider.Clear();
}
if (string.IsNullOrEmpty(ReleaseYearTextBox.Text) || ReleaseYearTextBox.Text == "Введите год выпуска альбома" || ReleaseYearTextBox.Text == " ")
{
ReleaseYearErrorProvider.SetError(ReleaseYearTextBox, "Поле года релиза должно быть заполнено");
if (result == true)
{
result = false;
}
}
else
{
int res;
bool isInt = Int32.TryParse(ReleaseYearTextBox.Text, out res);
if (!isInt)
{
ReleaseYearErrorProvider.SetError(ReleaseYearTextBox, "Поле года должно быть целым числом");
if (result == true)
{
result = false;
}
}
else if (res > DateTime.Now.Year)
{
ReleaseYearErrorProvider.SetError(ReleaseYearTextBox, "Год не должен быть больше текущего");
if (result == true)
{
result = false;
}
}
else if (res < 1000)
{
ReleaseYearErrorProvider.SetError(ReleaseYearTextBox, "Введите корректный год");
if (result == true)
{
result = false;
}
}
else
{
ReleaseYearErrorProvider.Clear();
}
}
if (string.IsNullOrEmpty(TypeComboBox.Text) || TypeComboBox.Text == "Выберите тип альбома" || TypeComboBox.Text == " ")
{
TypeErrorProvider.SetError(TypeComboBox, "Поле типа альбома должно быть заполнено");
if (result == true)
{
result = false;
}
}
else
{
TypeErrorProvider.Clear();
}
if (string.IsNullOrEmpty(CarrierComboBox.Text) || CarrierComboBox.Text == "Выберите тип носителя альбома" || CarrierComboBox.Text == " ")
{
CarrierTypeErrorProvider.SetError(CarrierComboBox, "Поле типа носителя альбома должно быть заполнено");
if (result == true)
{
result = false;
}
}
else
{
CarrierTypeErrorProvider.Clear();
}
if (string.IsNullOrEmpty(TrackCountTextBox.Text) || TrackCountTextBox.Text == "Введите количество дорожек в альбоме" || TrackCountTextBox.Text == " ")
{
TrackCountErrorProvider.SetError(TrackCountTextBox, "Поле количнства дорожек должно быть заполнено");
if (result == true)
{
result = false;
}
}
else
{
int res;
bool isInt = Int32.TryParse(TrackCountTextBox.Text, out res);
if (!isInt)
{
TrackCountErrorProvider.SetError(TrackCountTextBox, "Количество дорожек должно быть целым числом");
if (result == true)
{
result = false;
}
}
else if (res <= 0)
{
TrackCountErrorProvider.SetError(TrackCountTextBox, "Количетсов дорожек не может быть равно или меньше нуля");
if (result == true)
{
result = false;
}
}
else
{
TrackCountErrorProvider.Clear();
}
}
if (string.IsNullOrEmpty(ReleaseLabelTextBox.Text) || ReleaseLabelTextBox.Text == "Введите название выпускающего лэйбла" || ReleaseLabelTextBox.Text == " ")
{
ReleaseLabelErrorProvider.SetError(ReleaseLabelTextBox, "Поле выпускающего лэйбла должно быть заполнено");
if (result == true)
{
result = false;
}
}
else
{
ReleaseLabelErrorProvider.Clear();
}
return(result);
}
private List <Album> GetDataByFilter()
{
MusicAlbumsGuideDB context = new MusicAlbumsGuideDB();
string Default = "";
List <Album> allAlbums = context.Albums.Include(p => p.Author).Include(p => p.Carrier).Include(p => p.Genre).Include(p => p.ReleasingLabel).Include(p => p.Type).ToList();
if (FilterAndSearchConfig.FilterGenre != Default)
{
string[] Genres = FilterAndSearchConfig.FilterGenre.Split(';');
List <Album> findedAlbums = new List <Album>();
foreach (string s in Genres)
{
List <Album> finded = allAlbums.Where(p => p.Genre.Name == s).ToList();
foreach (Album a in finded)
{
findedAlbums.Add(a);
}
allAlbums = findedAlbums;
}
}
if (FilterAndSearchConfig.FilterAuthor != Default)
{
string[] Authors = FilterAndSearchConfig.FilterAuthor.Split(';');
List <Album> findedAlbums = new List <Album>();
foreach (string s in Authors)
{
List <Album> finded = allAlbums.Where(p => p.Author.Name == s).ToList();
foreach (Album a in finded)
{
findedAlbums.Add(a);
}
allAlbums = findedAlbums;
}
}
if (FilterAndSearchConfig.FilterCarrier != Default)
{
string[] Carriers = FilterAndSearchConfig.FilterCarrier.Split(';');
List <Album> findedAlbums = new List <Album>();
foreach (string s in Carriers)
{
List <Album> finded = allAlbums.Where(p => p.Carrier.Name == s).ToList();
foreach (Album a in finded)
{
findedAlbums.Add(a);
}
allAlbums = findedAlbums;
}
}
if (FilterAndSearchConfig.FilterReleaseYear != Default)
{
string[] ReleaseYears = FilterAndSearchConfig.FilterReleaseYear.Split(';');
List <Album> findedAlbums = new List <Album>();
foreach (string s in ReleaseYears)
{
List <Album> finded = allAlbums.Where(p => p.ReleaseYear.ToString() == s).ToList();
foreach (Album a in finded)
{
findedAlbums.Add(a);
}
allAlbums = findedAlbums;
}
}
if (FilterAndSearchConfig.FilterReleasingLabel != Default)
{
string[] ReleasingLabels = FilterAndSearchConfig.FilterReleasingLabel.Split(';');
List <Album> findedAlbums = new List <Album>();
foreach (string s in ReleasingLabels)
{
List <Album> finded = allAlbums.Where(p => p.ReleasingLabel.Name == s).ToList();
foreach (Album a in finded)
{
findedAlbums.Add(a);
}
allAlbums = findedAlbums;
}
}
if (FilterAndSearchConfig.FilterTrackCount != Default)
{
string[] TrackCounts = FilterAndSearchConfig.FilterTrackCount.Split(';');
List <Album> findedAlbums = new List <Album>();
foreach (string s in TrackCounts)
{
List <Album> finded = allAlbums.Where(p => p.TrackCount.ToString() == s).ToList();
foreach (Album a in finded)
{
findedAlbums.Add(a);
}
allAlbums = findedAlbums;
}
}
if (FilterAndSearchConfig.FilterType != Default)
{
string[] Types = FilterAndSearchConfig.FilterType.Split(';');
List <Album> findedAlbums = new List <Album>();
foreach (string s in Types)
{
List <Album> finded = allAlbums.Where(p => p.Type.Name == s).ToList();
foreach (Album a in finded)
{
findedAlbums.Add(a);
}
allAlbums = findedAlbums;
}
}
allAlbums = SortAlbums(allAlbums);
return(allAlbums);
}
