Example #1
1
        /// <summary>
        /// Metodo encargado de buscarcanciones en una carpeta para su importaci'on en la biblioteca de usuario
        /// </summary>
        /// <param name="directoryPath">Ruta de acceso a directorio</param>
        public void ImportSongsToLibrary(String directoryPath)
        {
            List<TrackInfo> tracksToInsert = new List<TrackInfo>();
            SessionManager sessionManager= SessionManager.Instance;
            string unknownFrame = "Unknown";
            string[] musicFiles = Directory.GetFiles(directoryPath, "*.mp3");
            foreach (string musicFile in musicFiles)
            {
                UserTrackRepository userTrackRepository = new UserTrackRepository();
                TrackRepository trackRepository = new TrackRepository();

                using (var mp3 = new Mp3File(musicFile))
                {
                    TrackInfo currentTrack = new TrackInfo() {TrackId = Guid.NewGuid()};

                    if (mp3.HasTags)
                    {
                        Id3Tag tag = mp3.GetTag(Id3TagFamily.FileStartTag);
                        if (tag != null)
                        {
                            currentTrack.Title = tag.Title.IsAssigned ? tag.Title.Value : unknownFrame;
                            currentTrack.AlbumTitle = tag.Album.IsAssigned ? tag.Album.Value : unknownFrame;
                            currentTrack.ArtistTitle = tag.Artists.IsAssigned ? tag.Artists : unknownFrame;
                            currentTrack.Genre = getGenre(tag.Genre.Value);
                            if (tag.Lyrics.Count != 0)
                            {
                                currentTrack.Lyric = tag.Lyrics[0].IsAssigned ? tag.Lyrics[0].Lyrics : "";
                            }
                            else
                            {
                                currentTrack.Lyric = "";
                            }
                            if (tag.Year.IsAssigned)
                            {
                                int year;
                                if (Int32.TryParse(tag.Year.Value, out year))
                                {
                                    currentTrack.Year = year;
                                }
                            }
                        }
                        else
                        {
                            currentTrack.Title = unknownFrame;
                            currentTrack.AlbumTitle =unknownFrame;
                            currentTrack.ArtistTitle = unknownFrame;
                            currentTrack.Genre = unknownFrame;
                            currentTrack.Lyric = "";
                            currentTrack.Year = 0;
                        }
                                     
                        currentTrack.SongPath = musicFile;
                        currentTrack.TrackId = Guid.NewGuid();
                        tracksToInsert.Add(currentTrack);
                    }
                    else
                    {
                        currentTrack.Title =unknownFrame;
                        currentTrack.AlbumTitle = unknownFrame;
                        currentTrack.ArtistTitle =unknownFrame;
                        currentTrack.Genre = unknownFrame;
                        currentTrack.Lyric = "";
                        currentTrack.SongPath = musicFile;
                        currentTrack.TrackId= Guid.NewGuid();
                        currentTrack.Year = 0;
                        tracksToInsert.Add(currentTrack);
                    }
                }
            }
            this.userTracks.AddRange(tracksToInsert);
            this.InsertIntoDatabase(tracksToInsert);
        }
Example #2
0
        public void GetAll()
        {
            ITrackRepository repository = new TrackRepository(_context);
            var entities = repository.GetTracksAll("%aero%");

            Assert.IsTrue(entities.Count() > 0);
        }
Example #3
0
        static void Main(string[] args)
        {
            var syncData          = new SyncData();
            var configXmlProvider = new ConfigXmlProvider(syncData);
            var webHelper         = new WebHelperService();
            var configSettings    = new ConfigSettings(configXmlProvider);
            var logger            = new ErrorLoggingService(webHelper, configSettings);

            try
            {
                var trackXmlParser   = new TrackXmlParser();
                var trackXmlProvider = new TrackXmlProvider(syncData);
                var trackRepository  = new TrackRepository(trackXmlParser, trackXmlProvider);
                var cloudService     = new AzureService(syncData);
                var taggingService   = new TagLibService();

                var service = new Service(trackRepository, cloudService, logger, syncData, taggingService);

                service.Run();
            }
            catch (Exception ex)
            {
                logger.Log(ex);
            }
        }
Example #4
0
 public UnitOfWork(bool test = false)
 {
     if (!test && !Test)
     {
         AccountTypes   = new AccountTypeRepository(new AccountTypeOracleContext());
         Employees      = new EmployeeRepository(new EmployeeOracleContext());
         AttachedTracks = new AttachedTrackRepository(new AttachedTrackOracleContext());
         Routes         = new RouteRepository(new RouteOracleContext());
         Sectors        = new SectorRepository(new SectorOracleContext());
         Statuses       = new StatusRepository(new StatusOracleContext());
         Tracks         = new TrackRepository(new TrackOracleContext());
         //TrackRoutes = new TrackRouteRepository(new TrackRouteOracleContext());
         Trams      = new TramRepository(new TramOracleContext());
         TramRoutes = new TramRouteRepository(new TramRouteOracleContext());
         Tasks      = new TaskRepository(new TaskOracleContext());
     }
     else
     {
         AccountTypes   = new AccountTypeRepository(new AccountTypeTestContext());
         Employees      = new EmployeeRepository(new EmployeeTestContext());
         Tracks         = new TrackRepository(new TrackTestContext());
         Sectors        = new SectorRepository(new SectorTestContext());
         Trams          = new TramRepository(new TramTestContext());
         Routes         = new RouteRepository(new RouteTestContext());
         AttachedTracks = new AttachedTrackRepository(new AttachedTrackTestContext());
         TramRoutes     = new TramRouteRepository(new TramRouteTestContext());
         TrackRoutes    = new TrackRouteRepository(new TrackRouteTestContext());
         TramStatuses   = new TramStatusRepository(new TramStatusTestContext());
     }
 }
        public TrackPage(TrackViewModel tvm)
        {
            InitializeComponent();

            if (tvm == null)
            {
                SetControlsVisible(Visibility.Hidden);
                return;
            }

            var trackRepo     = new TrackRepository();
            var previewSource = trackRepo.GetPreviewSource(tvm.TrackId);

            this.DataContext = _vm = new TrackPageViewModel
            {
                Artist       = tvm.Artist,
                Title        = tvm.Title,
                Image        = tvm.Image,
                AudioTrack   = previewSource,
                Playtime     = tvm.PlayTime,
                Popularity   = tvm.Popularity,
                DiscNumber   = tvm.DiscNumber,
                LicensorName = tvm.LicensorName,
                LabelName    = tvm.LabelName,
                ReleaseDate  = tvm.ReleaseDate,
                PackageType  = tvm.PackageType,
                Price        = tvm.Price
            };

            StopTrack();
        }
Example #6
0
 public TestInvoice()
 {
     _ChinookEntities = new ChinookEntities();
     _InvoiceRepo     = new InvoiceRepository(_ChinookEntities);
     _CustomerRepo    = new CustomerRepository(_ChinookEntities);
     _TrackRepo       = new TrackRepository(_ChinookEntities);
 }
        public int?StartOrResumeTrack(string authKey, int routeListId)
        {
            try
            {
                using (var uow = UnitOfWorkFactory.CreateWithoutRoot("[ADS]Старт записи трека"))
                {
                    if (!CheckAuth(authKey))
                    {
                        return(null);
                    }

                    var track = TrackRepository.GetTrackForRouteList(uow, routeListId);

                    if (track != null)
                    {
                        return(track.Id);
                    }

                    track = new Track();

                    track.RouteList = uow.GetById <RouteList>(routeListId);
                    track.Driver    = EmployeeRepository.GetDriverByAuthKey(uow, authKey);
                    track.StartDate = DateTime.Now;
                    uow.Save(track);
                    uow.Commit();

                    return(track.Id);
                }
            }
            catch (Exception e)
            {
                logger.Error(e);
            }
            return(null);
        }
Example #8
0
        public async Task Update_given_existing_track_Updates_properties()
        {
            var context = new Mock <ISlotCarContext>();
            var entity  = new Track {
                Id = 42
            };

            context.Setup(c => c.Tracks.FindAsync(42)).ReturnsAsync(entity);

            using (var repository = new TrackRepository(context.Object))
            {
                var track = new TrackUpdateDTO
                {
                    Id             = 42,
                    Name           = "name",
                    LengthInMeters = 12.5,
                    BestLap        = TimeSpan.FromSeconds(6.3),
                    MaxCars        = 4
                };

                await repository.Update(track);
            }

            Assert.Equal("name", entity.Name);
            Assert.Equal(12.5, entity.LengthInMeters);
            Assert.Equal(TimeSpan.FromSeconds(6.3).Ticks, entity.BestLapInTicks);
            Assert.Equal(4, entity.MaxCars);
        }
 public RepositoryManager(ShuflContext context)
 {
     AlbumRepository               = new AlbumRepository(context);
     AlbumArtistRepository         = new AlbumArtistRepository(context);
     AlbumImageRepository          = new AlbumImageRepository(context);
     ArtistRepository              = new ArtistRepository(context);
     ArtistImageRepository         = new ArtistImageRepository(context);
     ArtistGenreRepository         = new ArtistGenreRepository(context);
     GenreRepository               = new GenreRepository(context);
     GroupRepository               = new GroupRepository(context);
     GroupAlbumRepository          = new GroupAlbumRepository(context);
     GroupAlbumRatingRepository    = new GroupAlbumRatingRepository(context);
     GroupInviteRepository         = new GroupInviteRepository(context);
     GroupMemberRepository         = new GroupMemberRepository(context);
     GroupPlaylistRepository       = new GroupPlaylistRepository(context);
     GroupPlaylistRatingRepository = new GroupPlaylistRatingRepository(context);
     PasswordResetRepository       = new PasswordResetRepository(context);
     PlaylistRepository            = new PlaylistRepository(context);
     PlaylistImageRepository       = new PlaylistImageRepository(context);
     TrackRepository               = new TrackRepository(context);
     TrackArtistRepository         = new TrackArtistRepository(context);
     UserRepository             = new UserRepository(context);
     UserImageRepository        = new UserImageRepository(context);
     UserVerificationRepository = new UserVerificationRepository(context);
 }
Example #10
0
		/// <summary>
		/// Reads a quiz formatted as XML.
		/// </summary>
		/// <param name="trackRepository">The track repository.</param>
		/// <param name="xml">The XML.</param>
		/// <returns>A quiz.</returns>
		public Quiz FromXml(TrackRepository trackRepository, string xml)
		{
			string quizName = null;
			DateTime creationDate = DateTime.UtcNow;
			IEnumerable<Round> rounds;

			// Read quiz XML
			try {
				XDocument document = XDocument.Parse(xml);
				XElement quizNode = document.Element("quiz");

				XAttribute nameAttribute = quizNode.Attribute("name");
				if (nameAttribute != null)
					quizName = nameAttribute.Value;

				rounds = quizNode.Descendants("round")
					.Select(roundNode => new Round(
						roundNode.Attribute("name").Value,
						(PlayMode)Int32.Parse(roundNode.Attribute("playmode").Value),
						roundNode.Descendants("track")
							.Select(trackNode => trackRepository[trackNode.Value])
					));
			} catch (TrackNotFoundException ex) {
				throw new XmlException("Quiz contains a track not present in the track repository. " + ex.Filename);
			} catch (Exception ex) {
				throw new XmlException("Unable to read quiz.", ex);
			}

			// Create the quiz
			return new Quiz(quizName, creationDate, rounds);
		}
        public void DeleteOneTrack()
        {
            Track trackDelete = new Track
            {
                Id         = 3,
                Name       = "Pepe",
                Image      = "",
                Hour       = 2,
                MinSeconds = 30.1
            };

            listTrack.Add(trackDelete);
            var options = new DbContextOptionsBuilder <BetterCalmContext>()
                          .UseInMemoryDatabase(databaseName: "MSP.BetterCalmDatabase").Options;
            var context = new BetterCalmContext(options);

            listTrack.ForEach(track => context.Add(track));
            context.SaveChanges();
            repository = new TrackRepository(context);
            repository.Delete(trackDelete);
            context.Database.EnsureDeleted();
            Track getTrack = repository.Get(3);

            Assert.AreEqual(null, getTrack);
        }
        public static async void Run([TimerTrigger("*/10 * * * * *")] TimerInfo myTimer, TraceWriter log)
        {
            try
            {
                List <TrackAuth> tracks = await TrackRepository.GetRateLimitedTracks();

                int count = 0;
                foreach (var track in tracks)
                {
                    int postsLastHour = await PostRepository.PostsLastHourCount(track.RowKey);

                    if (postsLastHour <= track.rate_limit)
                    {
                        track.rate_limit_exceeded = false;
                        TrackRepository.UpdateTrack(track);
                        count++;
                    }
                }

                log.Info($"Removed rate limit on {count} tracks.");
            }
            catch (Exception e)
            {
                log.Error(e.Message);
            }
        }
Example #13
0
 public UnitOfWork(IDbFactory dbFactory)
 {
     this.dbFactory = dbFactory;
     Levels         = new LevelRepository(dbFactory);
     Locations      = new LocationRepository(dbFactory);
     Tracks         = new TrackRepository(dbFactory);
     Seminars       = new SeminarRepository(dbFactory);
 }
Example #14
0
        public TestCustomer()
        {
            _ChinookEntities = new ChinookEntities();

            _CustomerRepo = new CustomerRepository(_ChinookEntities);
            _TrackRepo    = new TrackRepository(_ChinookEntities);
            _PlayListRepo = new PlaylistRepository(_ChinookEntities);
        }
Example #15
0
        public void ViewTracks(IMainController _mainController, IShowTracksView inForm)
        {
            TrackRepository _trackRepository = TrackRepository.GetInstance();

            List <Track> tracks = _trackRepository.GetAllActiveTracks();

            inForm.ShowModaless(_mainController, tracks);
        }
Example #16
0
		/// <summary>
		/// Loads the track repository.
		/// </summary>
		/// <returns></returns>
		public async Task LoadTrackRepository()
		{
			StorageFolder musicPath = KnownFolders.MusicLibrary;
			StorageFile file = await musicPath.GetFileAsync("ttq_repository.xml");

			using (Stream stream = await file.OpenStreamForReadAsync())
				_trackRepository = TrackRepository.FromXml(stream);
		}
Example #17
0
 public LastFMImportJob()
 {
     _context          = new ApplicationDbContext();
     _userManager      = new ApplicationUserManager(new UserStore <ApplicationUser>(_context));
     _artistRepository = new ArtistRepository(_context);
     _albumRepository  = new AlbumRepository(_context);
     _trackRepository  = new TrackRepository(_context);
 }
Example #18
0
        /// <summary>
        /// DeleteTrackButton action
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <remarks>
        /// Delete indicated track
        /// </remarks>
        private void DeleteTrackButton_Click(object sender, RoutedEventArgs e)
        {
            var   trackRepo = new TrackRepository();
            Track track     = displayTracks.SelectedItem as Track;

            trackRepo.DeleteTrack(track.TrackId);
            this.NavigationService.Navigate(new DisplayTrackPage(track.ArtistId));
        }
Example #19
0
        public void TrackDataProviderTests()
        {
            TestConstants.Prepare();

            using (var pluginHost = new Plugins())
            {
                pluginHost.PluginDirectory = TestConstants.SimulatorsBinFolder;
                pluginHost.Load();

                Assert.Greater(pluginHost.Simulators.Count, 0);
                var testSim = pluginHost.Simulators[0];

                var w = new Stopwatch();

                w.Start();

                var mem       = GC.GetTotalMemory(true);
                var trackRepo = new TrackRepository(testSim.TrackProvider);
                var tracks    = trackRepo.GetIds().Count();

                w.Stop();
                Debug.WriteLine("[TIME] Retrieving ID list (" + tracks + ") costs " + w.ElapsedMilliseconds + "ms");
                w.Reset();

                w.Start();
                var Spa = trackRepo.GetByFile("67_SPA.GDB");
                Assert.AreNotEqual(null, Spa);
                Debug.WriteLine(Spa.Name + " " + Spa.Length);

                w.Stop();
                Debug.WriteLine("[TIME] Retrieving Spa 1967 costs " + w.ElapsedMilliseconds + "ms");
                w.Reset();

                // Building all tracks can take seconds.

                /*w.Start();
                 * foreach(var track in trackRepo.GetAll())
                 *  Debug.WriteLine(track.Name + "=" + track.Length);
                 * w.Stop();
                 * Debug.WriteLine("[TIME] Retrieving all tracks costs " + w.ElapsedMilliseconds + "ms");*/


                w.Start();

                Spa = trackRepo.GetByFile("67_SPA.GDB");
                Assert.AreNotEqual(null, Spa);
                Debug.WriteLine(Spa.Name + " " + Spa.Length);

                w.Stop();
                Debug.WriteLine("[TIME] Retrieving Spa 1967 costs " + w.ElapsedMilliseconds + "ms");
                Assert.LessOrEqual(w.ElapsedMilliseconds, 1);
                w.Reset();

                var dmem = GC.GetTotalMemory(true) - mem;
                Debug.WriteLine(dmem);
                w.Reset();
            }
        }
Example #20
0
        public void Test_AddingSameTrackReferenceTwice()
        {
            TrackRepository trackRepository = TrackRepository.GetInstance();

            Track track = new Track(trackRepository.GetNewID(), "Monza", "Italy", 1000);

            trackRepository.AddTrack(track);
            trackRepository.AddTrack(track);
        }
Example #21
0
        public async Task <IActionResult> OnGetAsync(string id)
        {
            var user = await _userManager.GetUserAsync(User);

            CurrentUser = user ?? throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
            Track       = await TrackRepository.GetTrackVerifyOwner(id, user.Id);

            return(Page());
        }
Example #22
0
 public UnitOfWork()
 {
     ArticleRepo  = new ArtisteRepository(_ChinookEntities);
     CustomerRepo = new CustomerRepository(_ChinookEntities);
     EmployeeRepo = new EmployeeRepository(_ChinookEntities);
     InvoiceRepo  = new InvoiceRepository(_ChinookEntities);
     PlaylistRepo = new PlaylistRepository(_ChinookEntities);
     TrackRepo    = new TrackRepository(_ChinookEntities);
 }
        public void TrackDataProviderTests()
        {
            TestConstants.Prepare();

            using (var pluginHost = new Plugins())
            {
                pluginHost.PluginDirectory = TestConstants.SimulatorsBinFolder;
                pluginHost.Load();

                Assert.Greater(pluginHost.Simulators.Count, 0);
                var testSim = pluginHost.Simulators[0];

                var w = new Stopwatch();

                w.Start();

                var mem = GC.GetTotalMemory(true);
                var trackRepo = new TrackRepository(testSim.TrackProvider);
                var tracks = trackRepo.GetIds().Count();

                w.Stop();
                Debug.WriteLine("[TIME] Retrieving ID list (" + tracks + ") costs " + w.ElapsedMilliseconds + "ms");
                w.Reset();

                w.Start();
                var Spa = trackRepo.GetByFile("67_SPA.GDB");
                Assert.AreNotEqual(null, Spa);
                Debug.WriteLine(Spa.Name + " " + Spa.Length);

                w.Stop();
                Debug.WriteLine("[TIME] Retrieving Spa 1967 costs " + w.ElapsedMilliseconds + "ms");
                w.Reset();

                // Building all tracks can take seconds.
                /*w.Start();
                foreach(var track in trackRepo.GetAll())
                    Debug.WriteLine(track.Name + "=" + track.Length);
                w.Stop();
                Debug.WriteLine("[TIME] Retrieving all tracks costs " + w.ElapsedMilliseconds + "ms");*/

                w.Start();

                Spa = trackRepo.GetByFile("67_SPA.GDB");
                Assert.AreNotEqual(null, Spa);
                Debug.WriteLine(Spa.Name + " " + Spa.Length);

                w.Stop();
                Debug.WriteLine("[TIME] Retrieving Spa 1967 costs " + w.ElapsedMilliseconds + "ms");
                Assert.LessOrEqual(w.ElapsedMilliseconds, 1);
                w.Reset();

                var dmem = GC.GetTotalMemory(true) - mem;
                Debug.WriteLine(dmem);
                w.Reset();
            }
        }
Example #24
0
        public void Dispose_disposes_context()
        {
            var context = new Mock <ISlotCarContext>();

            using (var repository = new TrackRepository(context.Object))
            {
            }

            context.Verify(c => c.Dispose());
        }
Example #25
0
 EditTrackRepository CreateEditRepository(TrackRepository repo) {
     if (!this.configsReader.HasConfig(repo.ConfigName))
         return null;
     return new EditTrackRepository() {
         Name = repo.Name,
         ConfigName = repo.ConfigName,
         RepoConfig = repo.ConfigName != null ? this.configsReader[repo.ConfigName] : null,
         Token = repo.Token,
         LocalPath = repo.LocalPath,
     };
 }
 public UnitOfWork(DatabaseContext context)
 {
     _context = context;
     //no olvidar inicializar
     Artisit   = new ArtitsRepository(_context);
     Tracks    = new TrackRepository(_context);
     playlist  = new Repository <Playlist>(_context);
     Genre     = new Repository <Genre>(_context);
     MediaType = new Repository <MediaType>(_context);
     Album     = new Repository <Album>(_context);
 }
        public async Task DotMemoryUnitTest()
        {
            var repo = new TrackRepository();

            await repo.GetAllAsync();

            dotMemory.Check(memory =>
                            Assert.Equal(1, memory.GetObjects(where => where.Type.Is <Track>()).ObjectsCount));

            GC.KeepAlive(repo); // prevent objects from GC if this is implied by test logic
        }
Example #28
0
        private (AppDbContext, ITrackRepository) Initialize(string DbName)
        {
            var options = new DbContextOptionsBuilder <AppDbContext>()
                          .UseInMemoryDatabase(databaseName: DbName)
                          .Options;
            var context = new AppDbContext(options);

            var query = new TrackRepository(context);

            return(context, query);
        }
Example #29
0
 EditTrackRepository CreateEditRepository(TrackRepository repo)
 {
     return(new EditTrackRepository()
     {
         Name = repo.Name,
         ConfigName = repo.ConfigName,
         RepoConfig = repo.ConfigName != null ? this.configsReader[repo.ConfigName] : null,
         Token = repo.Token,
         LocalPath = repo.LocalPath,
     });
 }
Example #30
0
        public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "track/{trackId}/follow")] HttpRequest req, string trackId, TraceWriter log)
        {
            try
            {
                // check postId and trackId provided
                if (!Tools.IsValidGuid(trackId))
                {
                    return(new UnauthorizedResult());
                }

                string authToken = req.Headers["Authorization"];

                if (authToken == null)
                {
                    return(new UnauthorizedResult());
                }

                // validate authKey
                AuthClaim authClaim = AuthRepository.ValidateAuthClaim(authToken);
                if (authClaim == null)
                {
                    return(new UnauthorizedResult());
                }

                // get the track
                TrackAuth track = await TrackRepository.GetTrack(trackId);

                if (track == null || (track.is_private && track.PartitionKey != authClaim.user_id))
                {
                    return(new UnauthorizedResult());
                }

                // trackFollow body
                string         requestBody = new StreamReader(req.Body).ReadToEnd();
                TrackFollowDTO dto         = JsonConvert.DeserializeObject <TrackFollowDTO>(requestBody);

                // insert or update the follow
                TrackFollow trackFollow = new TrackFollow();
                trackFollow.feed_follow_type          = dto.feed?.ToLower() == "all" || dto.feed?.ToLower() == "none" ? dto.feed.ToLower() : null;
                trackFollow.notifications_follow_type = dto.notifications?.ToLower() == "all" || dto.notifications?.ToLower() == "none" ? dto.notifications.ToLower() : null;
                trackFollow.criteria = dto.criteria;
                trackFollow.user_id  = authClaim.user_id;
                trackFollow.track_id = track.RowKey;

                FollowRepository.InsertOrReplaceTrackFollow(trackFollow);

                return(new OkResult());
            }
            catch (Exception e)
            {
                log.Error(e.Message);
                return(new UnauthorizedResult());
            }
        }
        public async void LoadTracks()
        {
            tracks = await TrackRepository.GetTracksAlbum(album.idAlbum);

            foreach (var track in tracks)
            {
                track.indexRow = tracks.IndexOf(track) + 1;
            }

            ListView_tracks.ItemsSource = tracks;
        }
Example #32
0
 public UnitOfWork(DatabaseContext context)
 {
     _context = context;
     // no olvidar inicializar todos los repositorios que se van a utilizar en este unit of work
     Artists    = new ArtistRepository(_context);
     Tracks     = new TrackRepository(_context);
     Playlists  = new Repository <Playlist>(_context);
     Genres     = new Repository <Genre>(_context);
     MediaTypes = new Repository <MediaType>(_context);
     Albums     = new Repository <Album>(_context);
 }
Example #33
0
        protected void OnButtonFromTrackClicked(object sender, EventArgs e)
        {
            var track = TrackRepository.GetTrackForRouteList(UoW, Entity.Id);

            if (track == null)
            {
                ServicesConfig.InteractiveService.ShowMessage(ImportanceLevel.Warning, "Невозможно расчитать растояние, так как в маршрутном листе нет трека", "");
                return;
            }
            Entity.ConfirmedDistance = (decimal)track.TotalDistance.Value;
        }
Example #34
0
        public void TrackRepositoryGetTracks_PathWithNoData_ReturnZeroLengthList_Test()
        {
            var repository = new TrackRepository("unidentified");

            var result = repository.GetTracks();

            Assert.IsNotNull(result);
            Assert.AreEqual(0, result.Count);
            Assert.IsTrue(Directory.Exists("unidentified"));

            Directory.Delete("unidentified", true);
        }
Example #35
0
        public void TrackRepositoryGetTracks_PathWithNoData_ReturnZeroLengthList_Test()
        {
            var repository = new TrackRepository("unidentified");

            var result = repository.GetTracks();

            Assert.IsNotNull(result);
            Assert.AreEqual(0, result.Count);
            Assert.IsTrue(Directory.Exists("unidentified"));

            Directory.Delete("unidentified", true);
        }
Example #36
0
        public void TrackRepositoryGetTracks_CorrectPath_ReturnCorrectlySavedData_Test()
        {
            var repository = new TrackRepository("trackrepo");

            var result = repository.GetTracks();

            Assert.IsNotNull(result);
            Assert.AreEqual(_testList.Count, result.Count);

            for (int i = 0; i < _testList.Count; i++)
            {
                Assert.AreEqual(_testList[i].CreatedDateTime, result[i].CreatedDateTime);
                Assert.AreEqual(_testList[i].Artist, result[i].Artist);
                Assert.AreEqual(_testList[i].Duration, result[i].Duration);
                Assert.AreEqual(_testList[i].Id, result[i].Id);
                Assert.AreEqual(_testList[i].OwnerId, result[i].OwnerId);
                Assert.AreEqual(_testList[i].Title, result[i].Title);
            }
        }
Example #37
0
        /// <summary>
        /// Metodo encargado de inicializar la biblioteca, carga los datos de las canciones desde la base de datos
        /// </summary>
        public void InitializeLibrary()
        {
            FileManager fileManager =new FileManager();
            fileManager.CreateUserDirectory();
            SessionManager sessionManager = SessionManager.Instance;
            TrackRepository trackRepo = new TrackRepository();
            UserTrackRepository userTrackRepo =new UserTrackRepository();
            List<Track> userStoredTracks= trackRepo.GetTraksByUserId(sessionManager.UserId);
            foreach (var userTrack in userStoredTracks)
            {
                TrackInfo trackInfo =new TrackInfo() {Title = userTrack.Title,TrackId = userTrack.TrackID,AlbumTitle = userTrack.Album.Title,
                                                      ArtistTitle = userTrack.Album.Artist.Title,SongPath = userTrack.Path,Year = userTrack.Album.ReleaseYear,
                                                      Lyric = userTrack.Lyrics,Genre = userTrack.Genre};
                trackInfo.isSynced = userTrackRepo.GetUserTrackByPK(sessionManager.UserId,trackInfo.TrackId).IsSync;
                this.userTracks.Add(trackInfo);
            }
            trackRepo.Dispose();
            userTrackRepo.Dispose();

        }
Example #38
0
        public void TrackRepositorySaveTracks_CorrectPath_SuccessfullyEnd_Test()
        {
            var repository = new TrackRepository("trackrepo");

            repository.SaveTracks(_testList);
        }
Example #39
0
        /// <summary>
        /// Metodo encargado de interactuar con la capa de datos para realizar las inserciones en la base de datos local
        /// </summary>
        /// <param name="tracksToInsert">Lista de tracks por ingresar</param>
        private void InsertIntoDatabase(List<TrackInfo> tracksToInsert)
         {
            ArtistRepository artistRepo = new ArtistRepository();
            AlbumRepository albumRepo =new AlbumRepository();
            TrackRepository trackRepo =new TrackRepository();
            UserTrackRepository usertracksRepo = new UserTrackRepository();
            foreach (TrackInfo trackInfo in tracksToInsert)
            {
                Artist trackArtist = GetArtistByTitle(trackInfo.ArtistTitle);
                if (trackArtist == null)
                {
                    //Creates new artist and insert into database
                    trackArtist = new Artist() {ArtistID = Guid.NewGuid(), Title = trackInfo.ArtistTitle};
                    artistRepo.Add(trackArtist);
                    artistRepo.SaveChanges();

                }
                else
                {
                    //artistRepo.Attach(trackArtist);
                }
                
                Album trackAlbum = GetAlbumByTitleAndArtistTitle(trackInfo.AlbumTitle,trackArtist.Title);
                if (trackAlbum == null)
                {
                    //Set trackAlbum as new Album
                    trackAlbum= new Album() {AlbumID = Guid.NewGuid(),ArtistID = trackArtist.ArtistID,Title = trackInfo.AlbumTitle, ReleaseYear = trackInfo.Year};
                    albumRepo.Add(trackAlbum);
                    albumRepo.SaveChanges();
                }
                else
                {
                    //albumRepo.Attach(trackAlbum);
                }
                //Creates new track
                Track newTrack=new Track() {AlbumID = trackAlbum.AlbumID,Title = trackInfo.Title, Genre =trackInfo.Genre,Lyrics = trackInfo.Lyric,Path = trackInfo.SongPath,TrackID = trackInfo.TrackId};
                usertracksRepo.Add(new UserTrack() {UserID = SessionManager.Instance.UserId,TrackID = trackRepo.Add(newTrack).TrackID,IsSync = false});
                //artistRepo.SaveChanges();
                
                
                
                trackRepo.SaveChanges();
                
            }
            usertracksRepo.SaveChanges();
            artistRepo.Dispose();
            trackRepo.Dispose();
            usertracksRepo.Dispose();

        }