private async Task LoadArtistRelatedTracks()
{
var returned = await _albumService.Get <List <Album> >(new AlbumSearchRequest()
{
ArtistId = ThisArtistId
});
var thisArtist = await _artistService.GetById <Artist>(ThisArtistId);
foreach (var item in returned)
{
var tracksInAlbum = await _trackService.Get <List <Track> >(new TrackSearchRequest()
{
AlbumId = item.AlbumId
});
foreach (var x in tracksInAlbum)
{
TrackHelperVM local = new TrackHelperVM()
{
AlbumId = item.AlbumId,
AlbumName = item.AlbumName,
ArtistId = (int)ThisArtistId,
ArtistName = thisArtist.ArtistName,
TrackId = x.TrackId,
TrackName = x.TrackName
};
Tracks.Add(local);
AllTracks.Add(local);
}
}
}
public async Task OnGetAsync(int?eventid)
{
Track = await _context.Tracks
.Where(e => e.SetTracks.Any(r => r.EventSet.EventId == eventid))
.ToListAsync();
AllTracks = await _context.Tracks.ToListAsync();
if (string.IsNullOrEmpty(SearchString))
{
return;
}
var searchStrings = SearchString.ToLower().Split(' ');
foreach (var searchString in searchStrings)
{
if (searchString[0] != '!')
{
AllTracks = AllTracks.Where(e => e.TrackName.ToLower().Contains((searchString))).ToList();
}
else
{
AllTracks = AllTracks.Where(e => !e.TrackName
.ToLower()
.Contains((searchString.Substring(1))))
.ToList();
}
}
}
private async Task <int> LoadSumTrackViewsForArtist(int artistId)
{
var allAlbums = await _albumService.Get <List <Album> >(new AlbumSearchRequest()
{
ArtistId = artistId
});
int sum = 0;
var thisArtist = await _artistService.GetById <Artist>(artistId);
foreach (var item in allAlbums)
{
var thisAlbumTracks = await _trackService.Get <List <Track> >(new TrackSearchRequest()
{
AlbumId = item.AlbumId
});
sum += thisAlbumTracks.Sum(a => (int)a.TrackViews);
foreach (var x in thisAlbumTracks)
{
TrackHelperVM local = new TrackHelperVM()
{
AlbumId = item.AlbumId,
AlbumName = item.AlbumName,
ArtistId = thisArtist.ArtistId,
ArtistName = thisArtist.ArtistName,
TrackId = x.TrackId,
TrackName = x.TrackName,
TrackViews = (int)x.TrackViews
};
AllTracks.Add(local);
}
}
return(sum);
}
private async Task Init()
{
var tracksintracklist = await _tracklistTrackService.Get <List <TracklistTrack> >(new TracklistTrackSearchRequest()
{
TracklistId = TracklistId
});
if (AddTracks == false)
{
foreach (var item in tracksintracklist)
{
var thisTrack = await _trackService.GetById <Track>(item.TrackId);
var thisAlbum = await _albumService.GetById <Album>(thisTrack.AlbumId);
var thisArtist = await _artistService.GetById <Artist>(thisAlbum.ArtistId);
TrackHelperVM local = new TrackHelperVM()
{
TrackId = thisTrack.TrackId,
TrackName = thisTrack.TrackName,
AlbumId = thisAlbum.AlbumId,
AlbumName = thisAlbum.AlbumName,
ArtistId = thisArtist.ArtistId,
ArtistName = thisArtist.ArtistName
};
Tracks.Add(local);
AllTracks.Add(local);
}
}
}
private async Task Clicked()
{
TracklistTrackUpsertRequest req = new TracklistTrackUpsertRequest()
{
DateAdded = DateTime.Now,
TrackId = SelectedTrack.TrackId,
TracklistId = TracklistId
};
try
{
if (AddTracks == true)
{
await _tracklistTrackService.Insert <TracklistTrack>(req);
}
else
{
await _tracklistTrackService.Update <TracklistTrack>(0, req);
}
Tracks.Remove(SelectedTrack);
AllTracks.Remove(SelectedTrack);
SelectedTrack = null;
}
catch (Exception ex)
{
await Application.Current.MainPage.DisplayAlert("Error", ex.Message, "OK");
}
}
internal static List <Track> GetStorageTracks(StationController station)
{
var trackNames = StorageTrackNames[station.stationInfo.YardID];
return(AllTracks
.Where(t => trackNames.Contains(t.ID.ToString()))
.ToList());
}
internal static List <Track> GetLoadingTracks(StationController station)
{
var trackNames = PlatformTrackNames[station.stationInfo.YardID];
var result = AllTracks.Where(t => trackNames.Contains(t.ID.ToString())).ToList();
return(result);
}
public static void LazyTest()
{
Print("Lazy Player 생성시작.");
LazyMediaPlayer player = new LazyMediaPlayer();
Print("Lazy Player. 생성완료.");
AllTracks yourMusic = player.GetAllTracks();
Print("Lazy Player. 트랙정보확인완료");
Print("");
}
public static void NonBigLazyTest()
{
Print("Non-Big-Lazy Player 생성시작.");
LazyBigMediaPlayer player = new LazyBigMediaPlayer();
Print("Non-Big-Lazy Player 생성완료.");
AllTracks yourMusic = player.GetAllTracks();
Print("Non-Big-Lazy 트랙정보확인완료");
Print("");
}
public bool AddSector(string _track)
{
int trackNumber = ToInt(_track);
foreach (Track track in AllTracks.Where(x => x.Number == trackNumber))
{
track.AddSector(new Sector(track.Sectors.Count + 1));
repo.AddSector(track.Sectors[track.Sectors.Count - 1], track);
Update();
return(true);
}
return(false);
}
public bool DeleteSector(string _track)
{
int trackNumber = ToInt(_track);
foreach (Track track in AllTracks.Where(x => x.Number == trackNumber && x.Sectors[x.Sectors.Count - 1].OccupyingTram == null))
{
track.DeleteSector();
repo.DeleteSectorFromTrack(track, track.Sectors[track.Sectors.Count - 1]);
Update();
return(true);
}
return(false);
}
public string MoveTram(int moveTram, int moveTrack, int moveSector, bool hasAccepted = false)
{
moveSector -= 1;
if (!AllTrams.ContainsKey(moveTram))
{
return("Deze tram bestaat niet.");
}
var tram = AllTrams[moveTram];
if (!hasAccepted && tram.Status != TramStatus.Idle)
{
return("NOT IDLE");
}
if (!AllTracks.ContainsKey(moveTrack))
{
return("Dit spoor betaat niet.");
}
var track = AllTracks[moveTrack];
if (track.Sectors.Count < moveSector + 1)
{
return($"Spoor {track.Number} heeft zo veel secoren niet");
}
var sector = track.Sectors[moveSector];
switch (sector.Status)
{
case SectorStatus.Locked:
return("Deze sector is afgesloten.");
case SectorStatus.Occupied:
return("Deze sector is bezet.");
case SectorStatus.Open:
{
var beheerSector = BeheerSector.ToBeheerSector(sector);
if (beheerSector != null && beheerSector.SetOccupyingTram(tram))
{
_repo.WipeSectorByTramId(tram.Number);
}
_repo.EditSector(beheerSector);
Update();
break;
}
default:
throw new ArgumentOutOfRangeException();
}
return(null);
}
public string AddSector(int trackNumber, decimal latitude, decimal longitude)
{
if (!AllTracks.ContainsKey(trackNumber))
{
return("Dit spoor bestaat niet.");
}
var track = AllTracks[trackNumber];
track.AddSector(new Sector(track.Sectors.Count + 1, track.Number, SectorStatus.Open, null, latitude,
longitude));
_repo.AddSector(track.Sectors[track.Sectors.Count - 1], track);
Update();
return(null);
}
static void Main(string[] args)
{
Debug.WriteLine("***** Fun with Lazy Instantiation *****\n");
// No allocation of AllTracks object here!
var myPlayer = new MediaPlayer();
myPlayer.Play();
// Allocation of AllTracks happens when you call GetAllTracks().
var yourPlayer = new MediaPlayer();
AllTracks yourMusic = yourPlayer.GetAllTracks();
//Debug.ReadLine();
}
static void Main()
{
Console.WriteLine("***** Fun with Lazy Instantiation *****\n");
// Никакого размещения объекта AllTracks!
var myPlayer = new MediaPlayer();
myPlayer.Play();
// Размещение объекта AllTracks происходит только в случае вызова метода GetAllTracks().
var yourPlayer = new MediaPlayer();
AllTracks yourMusic = yourPlayer.GetAllTracks();
Console.ReadLine();
}
public bool DeleteTrack(string _track)
{
int trackNumber = ToInt(_track);
foreach (Track track in AllTracks.Where(x => x.Number == trackNumber))
{
if (track.Sectors.Where(x => x.OccupyingTram != null).Count() > 0)
{
return(false);
}
repo.DeleteTrack(track);
Update();
return(true);
}
return(false);
}
public string DeleteTrack(int trackNumber)
{
if (!AllTracks.ContainsKey(trackNumber))
{
return("Dit spoor bestaat niet.");
}
var track = AllTracks[trackNumber];
if (track.Sectors.Any(x => x.OccupyingTram != null))
{
return("Er staat een tram op dit spoor. haal het eerst weg.");
}
_repo.DeleteTrack(track);
Update();
return(null);
}
private async Task LoadGenreRelatedTracks()
{
List <Artist> artistList = new List <Artist>();
var allArtistGenre = await _artistGenreService.Get <List <ArtistGenre> >(new ArtistGenreSearchRequest()
{
GenreId = (int)ThisGenreId
});
foreach (var item in allArtistGenre)
{
var thisArtist = await _artistService.GetById <Artist>(item.ArtistId);
artistList.Add(thisArtist);
}
foreach (var item in artistList)
{
var albumList = await _albumService.Get <List <Album> >(new AlbumSearchRequest()
{
ArtistId = item.ArtistId
});
foreach (var x in albumList)
{
var trackList = await _trackService.Get <List <Track> >(new TrackSearchRequest()
{
AlbumId = x.AlbumId
});
foreach (var y in trackList)
{
TrackHelperVM local = new TrackHelperVM()
{
AlbumId = x.AlbumId,
AlbumName = x.AlbumName,
ArtistId = item.ArtistId,
ArtistName = item.ArtistName,
TrackId = y.TrackId,
TrackName = y.TrackName
};
AllTracks.Add(local);
Tracks.Add(local);
}
}
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
AllTracks = await _context.Tracks.ToListAsync();
EventSet = await _context.EventSets
.Include(e => e.Dj)
.Include(e => e.Event)
.Include(e => e.SetTracks)
.ThenInclude(e => e.Track)
.FirstOrDefaultAsync(m => m.EventSetId == id);
if (string.IsNullOrEmpty(SearchString))
{
return(Page());
}
var searchStrings = SearchString.ToLower().Split(' ');
foreach (var searchString in searchStrings)
{
if (searchString[0] != '!')
{
AllTracks = AllTracks.Where(e => e.TrackName.ToLower().Contains((searchString))).ToList();
}
else
{
AllTracks = AllTracks.Where(e => !e.TrackName
.ToLower()
.Contains((searchString.Substring(1))))
.ToList();
}
}
if (EventSet == null)
{
return(NotFound());
}
return(Page());
}
//_______________________________________________________________________________//
private List <SelectListItem> getSelectlistAvailableTracksInAlbum(int?albumId)
{
List <Track_Album> track_albums = T_aDB.GetAllTracksFromAlbum((int)albumId);
IEnumerable <int> trackIDs = track_albums.Select(t_a => t_a.TrackId);
IEnumerable <Track> AllTracks;
using (TrackRepository TrackDB = new TrackRepository())
{
AllTracks = TrackDB.GetAll().Where(t => !trackIDs.Contains(t.Id));
}
return(AllTracks.Select(t =>
new SelectListItem
{
Text = t.name,
Value = t.Id.ToString()
}).ToList());
}
private async Task LoadTracks()
{
var tracksReturned = await _trackService.Get <List <Model.Track> >(null);
foreach (var item in tracksReturned)
{
TrackHelperVM local = new TrackHelperVM()
{
TrackId = item.TrackId,
TrackName = item.TrackName,
AlbumName = AllAlbums.Where(a => a.AlbumId == item.AlbumId).Select(a => a.AlbumName).FirstOrDefault(),
AlbumId = item.AlbumId
};
local.ArtistId = AllAlbums.Where(a => a.AlbumId == local.AlbumId).Select(a => a.ArtistId).FirstOrDefault();
local.ArtistName = AllArtists.Where(a => a.ArtistId == local.ArtistId).Select(a => a.ArtistName).FirstOrDefault();
AllTracks.Add(local);
QueryTracks.Add(local);
}
}
internal static List <Track> GetLoadingTracks(StationController station)
{
var trackNames = PlatformTrackNames[station.stationInfo.YardID];
var result = AllTracks.Where(t => trackNames.Contains(t.ID.ToString())).ToList();
// fix track IDs at Food Factory
foreach (var track in result)
{
if (track.ID.FullDisplayID == "#Y-#S-168-#T") // used to be #Y-#S-354-#T
{
track.OverrideTrackID(new TrackID("FF", "B", "1", TrackID.LOADING_PASSENGER_TYPE));
}
else if (track.ID.FullDisplayID == "#Y-#S-491-#T") // used to be #Y-#S-339-#T
{
track.OverrideTrackID(new TrackID("FF", "B", "2", TrackID.LOADING_PASSENGER_TYPE));
}
}
return(result);
}
public bool MoveTram(string _tram, string _track, string _sector)
{
int moveTram = ToInt(_tram);
int moveTrack = ToInt(_track);
int moveSector = ToInt(_sector) - 1;
foreach (Track track in AllTracks.Where(x => x.Number == moveTrack && x.Sectors.Count > moveSector))
{
foreach (Tram tram in AllTrams.Where(x => x.Number == moveTram))
{
BeheerSector beheerSector = track.Sectors[moveSector] == null ? null : BeheerSector.ToBeheerSector(track.Sectors[moveSector]);
if (beheerSector.SetOccupyingTram(tram))
{
repo.WipeSectorByTramId(tram.Number);
repo.EditSector(beheerSector);
Update();
return(true);
}
}
}
return(false);
}
public string DeleteSector(int trackNumber)
{
if (!AllTracks.ContainsKey(trackNumber))
{
return("Dit spoor bestaat niet.");
}
var track = AllTracks[trackNumber];
var sector = track.Sectors.Last();
if (sector == null)
{
return("Dit spoor heeft geen sectoren.");
}
if (sector.OccupyingTram != null)
{
return("Er staat een tram op deze sector. Haal deze eerst weg.");
}
track.DeleteSector();
_repo.DeleteSectorFromTrack(track, sector);
Update();
return(null);
}
// GET: Album/Tracks/5
public ActionResult Tracks(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Album album = AlbumDB.Find(id);
if (album == null)
{
return(HttpNotFound());
}
List <Track_Album> track_albums = T_aDB.GetAllTracksFromAlbum((int)id);
IEnumerable <int> trackIDs = track_albums.Select(t_a => t_a.TrackId);
IEnumerable <Track> AllTracks;
using (TrackRepository TrackDB = new TrackRepository())
{
AllTracks = TrackDB.GetAll().Where(t => !trackIDs.Contains(t.Id));
}
ViewBag.TrackAlbumSelectList = AllTracks.Select(t =>
new SelectListItem
{
Text = t.name,
Value = t.Id.ToString()
}).ToList();
return(View(new Track_AlbumCreateList()
{
track_album = new Track_Album(),
ExistingTrack_Albums = track_albums
}));
}
public void AttachTrackToStation(Track track)
{
SelectedTracks.Add(track);
AllTracks.Remove(track);
}
public void RemoveTrackFromStation(Track track)
{
SelectedTracks.Remove(track);
AllTracks.Add(track);
}
private void LoadTracks()
{
PopularTracks.AddRange(AllTracks.OrderByDescending(a => (int)a.TrackViews).ToList().Take(5));
RandomTracks.AddRange(AllTracks.OrderBy(a => Guid.NewGuid()).ToList().Take(5));
}
public static Track FindTrackWithId(string id)
{
return(AllTracks.FirstOrDefault(t => id.Equals(t.ID.ToString())));
}
public string Lock(string tracks, string sectors)
{
int[] lockSectors = { -1 };
int[] lockTracks;
try
{
if (!string.IsNullOrEmpty(sectors))
{
lockSectors = Parse(sectors);
for (var i = 0; i < lockSectors.Length; i++)
{
lockSectors[i] -= 1;
}
}
lockTracks = Parse(tracks);
}
catch
{
return("De input klopt niet.");
}
if (lockTracks[0] == -1)
{
return(null);
}
var newLockTracks = AllTracks.Where(x => lockTracks.Contains(x.Key));
foreach (var track in newLockTracks)
{
var beheerTrack = BeheerTrack.ToBeheerTrack(track.Value);
beheerTrack.LockTrack();
_repo.EditTrack(beheerTrack);
}
foreach (var track in AllTracks)
{
if (Array.IndexOf(lockTracks, track.Key) <= -1)
{
continue;
}
for (var i = 0; i < track.Value.Sectors.Count - 1; i++)
{
if (Array.IndexOf(lockSectors, i) <= -1)
{
continue;
}
var beheerSector = track.Value.Sectors[i] == null
? null
: BeheerSector.ToBeheerSector(track.Value.Sectors[i]);
if (beheerSector == null)
{
continue;
}
beheerSector.Lock();
_repo.EditSector(beheerSector);
}
}
Update();
return(null);
}
