/// <summary> /// This method checks if a file is inserted in the database. The check isn't case-sensitive. /// </summary> /// <param name="path"> /// A searchcriteria. It's the filepath of the MP3-File /// </param> /// <param name="filename"> /// A searchcriteria. It's the filename of the file /// </param> /// <returns> /// True if the file is in the database, false else /// </returns> public bool ExistFileInDatabase(String path, String filename) { log.DebugFormat("ExistFileInDatabase: path={0}, filename={1}", path, filename); if (path == null) throw new ArgumentNullException("path"); if (filename == null) throw new ArgumentNullException("filename"); using (var context = new MP3ManagerContext()) { var titles = context.Titles; var check = from e in titles where e.Path.ToUpper() == @path.ToUpper() && e.Filename.ToUpper() == @filename.ToUpper() select e.Id; int count = check.Count(); log.DebugFormat("count={0}", count); return count > 0; } }
/// <summary> /// Diese Methode löscht einen Titel aus der Datenbank.Sollte kein weiterer Titel mit dem Album verknüpft sein, /// so wird auch das Album gelöscht.Sollte kein weiterer Titel mit den Interpret verknüpft sein, so wird auch der Interpret gelöscht. /// Sollte ein gültiger Dateiname mi dem Titel verknüpft sein, so erfolgt die Löschung erst nach der Bestätigung duch den Benutzer. /// </summary> /// <param name="title"></param> public void DeleteTitle(Title title) { string filename = title.Path + title.Filename; if (File.Exists(filename)) { DialogResult result = MessageBox.Show("Es ist eine gültige Datei mit diesem Eintrag verknüpft. Sind Sie sicher, dass sie diesen Eintrag und die Datei löschen wollen?", "Info", MessageBoxButtons.YesNo); if (result == DialogResult.No) { return; } //Lösche die Datei File.Delete(filename); } //Lösche den Eintrag in der Datenbank long titleId = title.Id; long albumId = title.AlbumId; long interpretId = title.InterpretId; using (var context = new MP3ManagerContext()) { //Ist kein weitere Titel mehr zum Album zugeordnet, so lösche das Album int countAlbum = context.Titles.Where(e => e.AlbumId == title.AlbumId) .Where(e => e.Id != title.Id) .Count(); if (countAlbum == 0) { var reloadedAlbum = context.Albums .Where(e => e.Id == title.AlbumId) .FirstOrDefault(); if (reloadedAlbum != null) { context.Albums.Remove(reloadedAlbum); } } //Ist kein weiterer Titel diesem Interpret zugeordnet, dann lösche den Interpreten int countInterpret = context.Titles.Where(e => e.InterpretId == title.InterpretId) .Where(e => e.Id != title.Id) .Count(); if (countInterpret == 0) { var reloadedInterpret = context.Interprets .Where(e => e.Id == title.InterpretId) .FirstOrDefault(); if (reloadedInterpret != null) { context.Interprets.Remove(reloadedInterpret); } } var reloadedTitle = context.Titles .Where(e => e.Id == title.Id) .FirstOrDefault(); if (reloadedTitle != null) { context.Titles.Remove(reloadedTitle); } context.SaveChanges(); } }
/// <summary> /// Diese Methode löscht die angegebene Row aus dem Dataset und aus der Datenbanktabelle /// </summary> /// <param name="album"></param> private void DeleteAlbum(Album album) { using (var context = new MP3ManagerContext()) { context.Albums.Remove(album); context.SaveChanges(); } }
/// <summary> /// Diese Methode löscht die Zeile des Interpreten aus dem Dataset und der Datenbank /// </summary> /// <param name="interpret"> /// Die Zeile die gelöscht werden soll /// </param> private void DeleteInterpret(Interpret interpret) { using (var context = new MP3ManagerContext()) { context.Interprets.Remove(interpret); context.SaveChanges(); } }
/// <summary> /// This method searches for the first occurance of an artist /// </summary> /// <param name="artist"> /// Searchcriteria of the artistname /// </param> /// <returns> /// Returns the first occurance of the artist, null else /// </returns> public Interpret FindArtist(string artist) { log.DebugFormat("FindArtist: artist={0}", artist); if (artist == null) { throw new ArgumentException("Artist == null"); } using (var context = new MP3ManagerContext()) { var interprets = context.Interprets; var retVal = from e in interprets where e.Searchname.ToUpper().Trim() == @artist.ToUpper().Trim() select e; if (retVal.Count() == 0) { log.Debug("FindArtist: Interpret nicht gefunden"); return null; } return retVal.First(); } }
/// <summary> /// Liefert alle Informationen zu fehlenden /// </summary> /// <returns></returns> public List<MusicBrainzInformation> GetMusicBrainzList() { using (var context = new MP3ManagerContext()) { var result = context.MusicBrainzInformation .Include("Album") .Include("Artist") .ToList(); return result; } }
/// <summary> /// Diese Methode liefert alle Titel, welche in einem Album vorhanden sind, welches noch nicht aktualisiert ist /// </summary> /// <returns></returns> internal List<WArtistAlbum> ReadTitlesToDownloadInformation() { using (var context = new MP3ManagerContext()) { var result = context.Titles .Include("Album") .Include("Interpret") .Where(e => e.Album.InformationStatus == InformationDownloadStatus.NotStarted) .Where(e => e.Album != null && e.Album.Name != "" && e.Album.Name != WMP3FileInfo.UNKNOWN_ALBUM) .Where(e => e.Interpret != null && e.Interpret.Name != "" && e.Interpret.Name != WMP3FileInfo.UNKNOWN_INTERPRET) .OrderBy(e => e.InterpretId) .ThenBy(e => e.AlbumId) .Select(e => new WArtistAlbum() { AlbumId = e.AlbumId, AlbumName = e.Album.Name, ArtistId = e.InterpretId, ArtistName = e.Interpret.Name }) .Distinct() .ToList(); return result; } }
/// <summary> /// Liefert die höchste TitleId /// </summary> /// <returns></returns> public int MaxTitleId() { using (var context = new MP3ManagerContext()) { long maxValue = context.Titles.Max(t => t.Id); return maxValue <= int.MaxValue ? (int)maxValue : int.MaxValue; } }
/// <summary> /// This method searches for tablerowsof the given paameters /// </summary> /// <param name="interpret"> /// Searchparameter for interpret /// </param> /// <param name="album"> /// Searchparameer for album /// </param> /// <param name="title"> /// Searchparameter for title /// </param> /// <returns></returns> public IEnumerable<WSearchItem> Search(string interpret, string album, string title) { if (String.IsNullOrWhiteSpace(interpret) && String.IsNullOrWhiteSpace(album) && String.IsNullOrWhiteSpace(title)) { List<WSearchItem> noSearchPara = new List<WSearchItem>(); return noSearchPara; } string interpretSearchString = CreateSearchname(interpret); string albumSearchString = CreateSearchname(album); string titleSearchString = CreateSearchname(title); using (var context = new MP3ManagerContext()) { var result = from titleRow in context.Titles join albumRow in context.Albums on titleRow.AlbumId equals albumRow.Id join artistRow in context.Interprets on titleRow.InterpretId equals artistRow.Id where !String.IsNullOrWhiteSpace(titleSearchString) && titleRow.Searchname.ToUpper().Trim().Contains(titleSearchString) || !String.IsNullOrWhiteSpace(albumSearchString) && albumRow.Searchname.ToUpper().Trim().Contains(albumSearchString) || !String.IsNullOrWhiteSpace(interpretSearchString) && artistRow.Searchname.ToUpper().Trim().Contains(interpretSearchString) orderby artistRow.Name, albumRow.Name, titleRow.Name select new WSearchItem { Interpret = artistRow, Album = albumRow, Title = titleRow }; return result.AsParallel().ToList(); } }
/// <summary> /// This method searches in title.name, interpret.name and album.name for the searchstring /// </summary> /// <param name="searchString"> /// SearchCriteria /// </param> /// <returns> /// Matched result /// </returns> public IEnumerable<WSearchItem> Search(string searchString) { log.DebugFormat("Search in Database: searchString={0}", searchString); string normalizeSearchString = CreateSearchname(searchString); using (var context = new MP3ManagerContext()) { var result = context.Titles .Include("Interpret") .Include("Album") .Where(e => e.Searchname.ToUpper().Trim().Contains(normalizeSearchString) || e.Album.Searchname.ToUpper().Trim().Contains(normalizeSearchString) || e.Interpret.Searchname.ToUpper().Trim().Contains(normalizeSearchString)) .OrderBy(e => e.Interpret.Name) .ThenBy(e => e.Album.Name) .ThenBy(e => e.Name) .Select(e => new WSearchItem { Interpret = e.Interpret, Album = e.Album, Title = e }); return result.AsParallel().ToList(); } }
/// <summary> /// This method inserts a new tile row /// </summary> /// <param name="mp3Info"> /// The data to insert /// </param> /// <param name="interpretRow"> /// The referenced interpret row /// </param> /// <param name="albumRow"> /// The referenced album row /// </param> /// <returns> /// The inserted title row if the insertion was successfull, null else /// </returns> private Title InsertTitle(WMP3FileInfo mp3Info, Interpret interpretRow, Album albumRow) { if (mp3Info == null) { throw new ArgumentException("mp3Info == null"); } if (interpretRow == null) { throw new ArgumentException("interpretRow == null"); } if (albumRow == null) { throw new ArgumentException("albumRow == null"); } if (String.IsNullOrWhiteSpace(mp3Info.Title)) { throw new ArgumentException("Title null or empty"); } log.DebugFormat("InsertTitle: tile={0}", mp3Info.Title); Title titleRow = null; long start = DateTime.Now.Ticks; using (var context = new MP3ManagerContext()) { string normalizedName = CreateSearchname(mp3Info.Title); titleRow = context.Titles.Add(new Title() { Interpret = interpretRow, Album = albumRow, Name = mp3Info.Title, Length = mp3Info.Songlength, Bitrate = mp3Info.BitRate, Bytes = mp3Info.Bytes, Path = mp3Info.Path, Filename = mp3Info.Filename, Searchname = normalizedName, Track = mp3Info.Track, CreationDate = DateTime.Now, EditDate = mp3Info.EditDate, IsOrdered = false, IsCollection = false, DurationInSeconds = mp3Info.DurationInSeconds, Genre = mp3Info.Genre, PublicationYear = mp3Info.PublicationYear, SampleRate = mp3Info.SampleRate, Channels = mp3Info.Channels }); context.SaveChanges(); return titleRow; } }
/// <summary> /// This method inserts a new row in the album table /// </summary> /// <param name="mp3Info"> /// The datato insert /// </param> /// <param name="interpretRow"> /// The referenced interpretRow /// </param> /// <returns> /// The new albumrrow if the innsertion was successfull, null else /// </returns> private Album InsertAlbum(WMP3FileInfo mp3Info) { if (mp3Info == null) { throw new ArgumentException("mp3Info == null"); } if (String.IsNullOrWhiteSpace(mp3Info.Album)) { mp3Info.Album = WMP3FileInfo.UNKNOWN_ALBUM; } log.DebugFormat("InsertAlbum: albumname={0}", mp3Info.Album); string normalizedName = CreateSearchname(mp3Info.Album); var albumRow = FindAlbum(normalizedName); if (albumRow == null) { log.Debug("Insert new Album"); using (var context = new MP3ManagerContext()) { albumRow = context.Albums.Add(new Album() { Name = mp3Info.Album, Searchname = normalizedName, InformationStatus = InformationDownloadStatus.NotStarted }); context.SaveChanges(); } } return albumRow; }
/// <summary> /// This method inserts a new interpret-row /// </summary> /// <param name="mp3Info"> /// The data of the interpeet-row /// </param> /// <returns> /// The new Row if the insertion was successfull, null else /// </returns> private Interpret insertInterpret(WMP3FileInfo mp3Info) { if (mp3Info == null) { throw new ArgumentException("mp3Info == null"); } if (String.IsNullOrWhiteSpace(mp3Info.Interpret)) { mp3Info.Interpret = WMP3FileInfo.UNKNOWN_INTERPRET; } log.DebugFormat("InsertInterpret: interpret={0}", mp3Info.Interpret); string normalizedName = CreateSearchname(mp3Info.Interpret); var interpretRow = FindArtist(normalizedName); if (interpretRow == null) { log.Debug("Insert new Interpret"); using (var context= new MP3ManagerContext()) { interpretRow = context.Interprets.Add(new Interpret() { Name=mp3Info.Interpret, Searchname = normalizedName }); context.SaveChanges(); } } return interpretRow; }
/// <summary> /// This method searches for the album of an artist /// </summary> /// <param name="albumname"> /// Searchcriterianame of the album /// </param> /// <param name="artist"> /// Searchcriteria Artist of the album /// </param> /// <returns> /// Returns the first occurance of the albu, null else /// </returns> public Album FindAlbum(string albumname) { using (var context = new MP3ManagerContext()) { var albums = context.Albums; var retVal = from album in albums where album.Searchname.ToUpper().Trim() == @albumname.ToUpper().Trim() select album; if (retVal.Count() == 0) { log.DebugFormat("FindAlbum: albumname={0}", albumname); return null; } return retVal.First(); } }
/// <summary> /// Diese Methode filtert die Elemente aus, die in die Datenbank nicht vorhanden sind /// </summary> /// <param name="fileInfos"> /// Eine Liste von Dateien, die überprüft werden müssen /// </param> /// <returns></returns> public IEnumerable<WFileInfo> ExtractDatabaseFromList(IEnumerable<WFileInfo> fileInfos) { List<WFileInfo> returnValues = new List<WFileInfo>(); if (fileInfos == null) { log.Warn("ExtractDatabaseFromList: fileInfos == null"); return returnValues; } using (var context = new MP3ManagerContext()) { var titles = context.Titles; var pathFilename = from title in titles select new { Filename = title.Filename, Path = title.Path }; var pathFilenameList = pathFilename.ToList(); foreach (var fi in fileInfos) { log.DebugFormat("ExtractDatabaseFromList: Überprüfe Datei path={0}, filename={1}", fi.Path, fi.Filename); bool doInsert = true; foreach (var listElement in pathFilenameList) { if (listElement.Filename == fi.Filename && listElement.Path == fi.Path) { doInsert = false; break; } } if (doInsert) { log.DebugFormat("ExtractDatabaseFromList: Füge Datei in Datenbank hinzu path={0}, filename={1}", fi.Path, fi.Filename); WFileInfo newInfo = new WFileInfo { Filename = fi.Filename, Path = fi.Path, Bytes = fi.Bytes, EditDate = fi.EditDate }; returnValues.Add(newInfo); } } } return returnValues; }
/// <summary> /// Liefert den Titel mit der angegebenen Id /// </summary> /// <param name="id"> /// Eindeutiger Titelschlüssel /// </param> /// <returns> /// Liefert den Titel mit der angegebenen Id /// </returns> public Title GetTitle(long id) { using (var context = new MP3ManagerContext()) { var title = (from t in context.Titles where t.Id == id select t).FirstOrDefault(); return title; } }
/// <summary> /// Liefert eine Liste der gespeicherten Titel /// </summary> /// <param name="reorderStatus"></param> /// <returns></returns> public IEnumerable<Title> FetchTitles(Boolean reorderStatus) { using (var context = new MP3ManagerContext()) { var retValue = from title in context.Titles where title.IsOrdered == reorderStatus select title; return retValue.ToList(); } }
/// <summary> /// Liefert die niedrigste TitleId /// </summary> /// <returns></returns> public int MinTitleId() { using (var context = new MP3ManagerContext()) { long minValue = context.Titles.Min(t => t.Id); return minValue >= int.MinValue && minValue <= int.MaxValue ? (int)minValue : int.MinValue; } }
/// <summary> /// Diese Methode aktualisiert die übergebene Zeile in der Datenbank /// </summary> /// <param name="elementToUpdate"></param> public void Update(Album elementToUpdate) { if (elementToUpdate == null) { throw new ArgumentException("elementToUpdate == null"); } log.DebugFormat("updateAlbum: id={0}", elementToUpdate.Id); using (var context = new MP3ManagerContext()) { context.Albums.Attach(elementToUpdate); context.SaveChanges(); } }
/// <summary> /// Speichert die Entität der MusicBrainz-Informationen /// </summary> /// <param name="albumId"> /// Der Primärschlüssel des Albums /// </param> /// <param name="entities"> /// Die Entitäten die in die Datenbank eingetragen werden sollen. /// </param> internal void AddMusicBrainzEntities(long albumId, List<MusicBrainzInformation> entities) { using (var context = new MP3ManagerContext()) { foreach (var entity in entities) { if (!context.MusicBrainzInformation.Any(e => e.TitleMBId == entity.TitleMBId)) { context.MusicBrainzInformation.Add(entity); } } var album = context.Albums.Where(e => e.Id == albumId).SingleOrDefault(); if (!context.Albums.Any(e => e.Id == albumId)) { string message = string.Format("Das Album mit der Id {0} konnte nicht gefunden werden.", albumId); log.Error(message); throw new EntityException(message); } album.InformationStatus = InformationDownloadStatus.Done; context.Entry(album).State = System.Data.Entity.EntityState.Modified; context.SaveChanges(); } }
/// <summary> /// This method updates the albums which are collections of different interprets /// </summary> public void SetCollections() { using (var context = new MP3ManagerContext()) { var titles = (from t1 in context.Titles from t2 in context.Titles where t1.AlbumId == t2.AlbumId && t1.InterpretId != t2.InterpretId && t1.IsCollection == false select t1).Distinct(); foreach (var title in titles) { if (log.IsDebugEnabled) { log.DebugFormat("Setze isCollection = true (ID = {0})", title.Id); } title.IsCollection = true; context.SaveChanges(); } } }
/// <summary> /// Liefert eine Liste mit Titelsn zum angegebenen Album /// </summary> /// <param name="albumMBId"></param> /// <returns></returns> public List<MusicBrainzInformation> GetTitles(string albumMBId) { using (var context = new MP3ManagerContext()) { var result = context.MusicBrainzInformation .Where(e => e.AlbumMBId == albumMBId) .ToList(); return result; } }
/// <summary> /// This method checks, if an artist is stored in the database /// </summary> /// <param name="artist"> /// The searchcriteria of the artist /// </param> /// <returns> /// True if the artist ist stored, false else /// </returns> public bool ExistArtist(string artist) { if (String.IsNullOrWhiteSpace(artist)) { log.Warn("ExistArtist: artist == null or empty"); } log.DebugFormat("ExistArtist:artist={0}", artist); using (var context = new MP3ManagerContext()) { var interprets = context.Interprets; var check = from e in interprets where e.Searchname.ToUpper().Trim() == @artist.ToUpper().Trim() select e.Name; int count = check.Count(); log.DebugFormat("ExistArtist: Count={0}", count); return check.Count() > 0; } }