public IActionResult New()
{
try
{
LoggerBundle.Trace("Registered PUT request on InviteController.New");
if (!IsAuthorized(out IActionResult result, u => u.CanInvite))
{
LoggerBundle.Trace("Request not authorized");
return(result);
}
// create new entry
String token = Guid.NewGuid().ToString("N").Substring(0, 16);
Invite invite = new Invite
{
CreateDate = DateTime.Now
, ExpirationDate = DateTime.Now.AddDays(14)
, Token = token
};
using (DataContext dc = DataContextFactory.GetInstance())
{
dc.SetUsers.Attach(AuthorizedUser);
AuthorizedUser.Invites.Add(invite);
dc.SaveChanges();
}
return(Ok(invite.ToJsonDictionary()));
}
catch (Exception ex)
{
return(HandleException(ex));
}
}
public static String GetToken(JwtPayload payload, String secret, Int32 expirationShift)
{
LoggerBundle.Trace("Generating JWT token...");
if (payload == null)
{
LoggerBundle.Trace("Validation failed: payload is null");
throw new ArgumentNullException(nameof(payload));
}
if (secret == null)
{
LoggerBundle.Trace("Validation failed: secret is null");
throw new ArgumentNullException(nameof(secret));
}
payload.Iat = DateTime.Now;
payload.Exp = payload.Iat.AddMinutes(expirationShift); // in minutes
IJwtAlgorithm algorithm = new HMACSHA256Algorithm();
IJsonSerializer serializer = new JsonNetSerializer();
IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
IJwtEncoder encoder = new JwtEncoder(algorithm, serializer, urlEncoder);
String encodedPayload = encoder.Encode(payload, secret);
LoggerBundle.Trace("Successfully generated token");
return(encodedPayload);
}
protected override void Process(String[] args)
{
OnProcessStarting();
TriggerActions(args.ToList());
List <Track> tracks;
do
{
using (DataContext dataContext = DataContextFactory.GetInstance())
{
LoggerBundle.Debug("Preloading data...");
Stopwatch sw = new Stopwatch();
sw.Start();
tracks = _includeFailed
? dataContext.SetTracks.Where(x => !x.LastFingerprintCalculation.HasValue || null != x.FingerprintError)
.Take(_config.BufferSize)
.ToList()
: dataContext.SetTracks.Where(x => !x.LastFingerprintCalculation.HasValue)
.Take(_config.BufferSize)
.ToList();
sw.Stop();
LoggerBundle.Debug($"Getting data finished in {sw.ElapsedMilliseconds}ms");
}
LoggerBundle.Inform($"Batch contains {tracks.Count} record(s).");
foreach (Track track in tracks)
{
LoggerBundle.Trace($"Initializing process for track '{track}'...");
while (_buffer.Count >= _config.ParallelProcesses)
{
Thread.Sleep(1);
}
LoggerBundle.Trace($"Starting process for track '{track}'...");
Process p = new Process
{
StartInfo =
{
FileName = FingerprintCalculationExecutablePath
, Arguments = $"-json \"{track.Path}\""
, CreateNoWindow = true
, RedirectStandardError = true
, RedirectStandardInput = true
, RedirectStandardOutput = true
, UseShellExecute = false
}
};
p.OutputDataReceived += (_, arguments) => HandleStdOutput(arguments, track);
p.ErrorDataReceived += (_, arguments) => HandleErrOutput(arguments, track);
_buffer.Add(track);
LoggerBundle.Trace($"Starting computation process for file '{track}'...");
p.Start();
p.BeginOutputReadLine();
p.BeginErrorReadLine();
LoggerBundle.Debug($"Computation process started for file '{track}'");
}
}while (tracks.Count > 0);
}
private void HandleErrOutput(DataReceivedEventArgs arguments, Track track)
{
LoggerBundle.Trace($"Processing error response of track '{track}'...");
try
{
String output = arguments?.Data?.Trim();
if (String.IsNullOrEmpty(output))
{
return;
}
LoggerBundle.Warn(new CalculationException(output));
track.FingerprintError = output;
track.LastFingerprintCalculation = DateTime.Now;
using (DataContext dataContext = DataContextFactory.GetInstance())
{
LoggerBundle.Trace($"Saving track '{track}'...");
dataContext.SetTracks.Attach(track);
dataContext.Entry(track).State = EntityState.Modified;
dataContext.SaveChanges();
LoggerBundle.Debug($"Successfully updated track '{track}'...");
}
}
catch (Exception ex)
{
LoggerBundle.Error(ex);
}
finally
{
_buffer.Remove(track);
}
}
public static T Request <T>(String path) where T : class
{
LoggerBundle.Debug($"Requested configuration '{path}'");
if (!File.Exists(path))
{
LoggerBundle.Trace($"File '{path}' not found. Trying to create it...");
FileInterface.Save(Activator.CreateInstance <T>(), path);
LoggerBundle.Trace($"Successfully created file '{path}'");
LoggerBundle.Inform(
$"Changes to the newly created file '{path}' will take effect after restarting the executable. Adjust default value as needed and restart the application.");
}
LoggerBundle.Trace($"Trying to read file '{path}'...");
(T result, Boolean success) = FileInterface.Read <T>(path);
if (!success)
{
LoggerBundle.Warn(new ProcessAbortedException());
return(null);
}
LoggerBundle.Debug($"Successfully read configuration file '{path}'");
return(result);
}
public IActionResult GetAll([FromQuery(Name = "ps")] Int32 pageSize = 50, [FromQuery(Name = "p")] Int32 page = 0)
{
try
{
LoggerBundle.Trace("Registered GET request on InviteController.GetAll");
if (!IsAuthorized(out IActionResult result, u => u.CanInvite))
{
LoggerBundle.Trace("Request not authorized");
return(result);
}
NormalizePageSize(ref pageSize);
// get data
using (DataContext dc = DataContextFactory.GetInstance())
{
return(Ok(dc.SetInvites.Include(x => x.CreateUser)
.Include(x => x.RegisteredUser)
.AsNoTracking()
.Where(x => x.CreateUser.CanInvite)
.Where(x => x.CreateUser.UniqueId.Equals(AuthorizedPayload.ClientId))
.OrderByDescending(x => x.CreateDate)
.Skip(page * pageSize)
.Take(pageSize)
.Select(x => x.ToJsonDictionary())
.ToList()));
}
}
catch (Exception ex)
{
return(HandleException(ex));
}
}
public IActionResult GetAll([FromQuery(Name = "ps")] Int32 pageSize = 50, [FromQuery(Name = "p")] Int32 page = 0)
{
try
{
LoggerBundle.Trace("Registered GET request on TracksController.GetAll");
if (!IsAuthorized(out IActionResult result))
{
LoggerBundle.Trace("Request not authorized");
return(result);
}
NormalizePageSize(ref pageSize);
// get data
using (DataContext dc = DataContextFactory.GetInstance())
{
return(Ok(dc.SetTracks.AsNoTracking()
.Skip(page * pageSize)
.Take(pageSize)
.Select(x => x.ToJsonDictionary())
.ToList()));
}
}
catch (Exception ex)
{
return(HandleException(ex));
}
}
private Program()
{
using (DataContext dc = DataContextFactory.GetInstance())
{
LoggerBundle.Debug("Trying to load data of every model type...");
foreach (Type t in Types)
{
LoggerBundle.Trace($"Loading data for set of type '{t.Name}'...");
MethodInfo setMethod = dc.GetType().GetMethods().First(x => x.Name.Equals("Set"));
MethodInfo setMethodGeneric = setMethod.MakeGenericMethod(t);
Object set = setMethodGeneric.Invoke(dc, new Object[] { });
MethodInfo methodLoad = typeof(EntityFrameworkQueryableExtensions).GetMethods()
.First(x => x.Name.Equals("Load"));
MethodInfo methodLoadGeneric = methodLoad.MakeGenericMethod(t);
methodLoadGeneric.Invoke(set
, new[]
{
set
});
dc.SetTracks.Load();
LoggerBundle.Trace("Loading data done.");
}
LoggerBundle.Debug("Done.");
}
}
public AcoustIdApiHandler(String apiKey)
{
LoggerBundle.Trace($"Initializing AcoustId API Handler with Kes '{apiKey}'");
_apiKey = apiKey;
LoggerBundle.Inform(
$"Notice: The AcoustId API is throttled to a maximum of {MAX_REQUESTS_PER_SECOND} requests per second due to their policy.");
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
LoggerBundle.Trace("Configuring context...");
optionsBuilder.UseSqlServer(_config.ConnectionString);
LoggerBundle.Trace("Context configured.");
}
protected override void OnInitialize()
{
LoggerBundle.Debug($"Initializing plugin '{Name}'...");
LoggerBundle.Trace("Requesting config...");
_config = RequestConfig <Config>();
LoggerBundle.Trace("Done.");
}
protected override void Process(String[] args)
{
OnProcessStarting();
TriggerActions(args.ToList());
List <String> paths = args.Distinct().Select(x => x.Trim()).ToList();
if (paths.Count.Equals(0))
{
LoggerBundle.Fatal(new ArgumentException("no argument given"));
Environment.Exit(1);
}
foreach (String path in paths)
{
LoggerBundle.Inform($"Processing path '{path}'...");
if (!Directory.Exists(path))
{
LoggerBundle.Warn($"Path '{path}' not found. Skipping.");
continue;
}
LoggerBundle.Debug("Preloading data...");
List <String> tracks;
Stopwatch sw = new Stopwatch();
sw.Start();
using (DataContext dataContext = DataContextFactory.GetInstance())
{
tracks = dataContext.SetTracks.AsNoTracking().Select(x => x.Path).ToList();
}
sw.Stop();
LoggerBundle.Debug($"Getting data finished in {sw.ElapsedMilliseconds}ms");
List <String> buffer = new List <String>();
DataSource <String> ds = new PathDataSource(path, _config.Extensions);
LoggerBundle.Inform($"Start to crawl path '{path}'...");
foreach (String file in ds.Get())
{
buffer.Add(file);
Int32 bufferCount = buffer.Count;
if (bufferCount < _config.BufferSize)
{
if (bufferCount % (_config.BufferSize < 1337 ? _config.BufferSize : 1337) == 0)
{
LoggerBundle.Trace($"Adding files to buffer [{bufferCount}/{_config.BufferSize}] ...");
}
continue;
}
ProcessBuffer(ref buffer, ref tracks);
}
ProcessBuffer(ref buffer, ref tracks);
}
}
public IActionResult GetAll([FromQuery(Name = "ps")] Int32 pageSize = 50, [FromQuery(Name = "p")] Int32 page = 0)
{
try
{
LoggerBundle.Trace("Registered GET request on PlaylistsController.GetAll");
if (!IsAuthorized(out IActionResult result))
{
LoggerBundle.Trace("Request not authorized");
return(result);
}
NormalizePageSize(ref pageSize);
// get data
using (DataContext dc = DataContextFactory.GetInstance())
{
dc.SetUsers.Attach(AuthorizedUser);
List <Playlist> playlists = dc.SetPlaylists.AsNoTracking()
.Include(x => x.CreateUser)
.Include(x => x.PlaylistPermissions)
.ThenInclude(x => x.User)
.Where(x => x.CreateUser.UniqueId.Equals(AuthorizedUser.UniqueId) ||
x.PlaylistPermissions.Any(y => y.User.UniqueId.Equals(AuthorizedUser.UniqueId)))
.OrderBy(x => x.Name)
.Skip(page * pageSize)
.Take(pageSize)
.ToList();
return(Ok(playlists.Select(x => new Dictionary <String, Object>
{
{
"UniqueId", x.UniqueId
}
,
{
"Name", x.Name
}
,
{
"CreateUser", x.CreateUser.ToJsonDictionary()
}
,
{
"CanModify"
, x.CreateUser.UniqueId.Equals(AuthorizedUser.UniqueId) ||
x.PlaylistPermissions.Any(y => y.User.UniqueId.Equals(AuthorizedUser.UniqueId) && y.CanModify)
}
})));
}
}
catch (Exception ex)
{
return(HandleException(ex));
}
}
public IActionResult Update(Int32?id, [FromBody] PlaylistModel model)
{
try
{
LoggerBundle.Trace("Registered UPDATE request on PlaylistsController.Update");
if (!IsAuthorized(out IActionResult result))
{
LoggerBundle.Trace("Request not authorized");
return(result);
}
// validate
if (!id.HasValue)
{
LoggerBundle.Trace("Validation failed: id is null");
return(StatusCode((Int32)HttpStatusCode.BadRequest));
}
String name = model.Name?.Trim();
if (String.IsNullOrWhiteSpace(name) || name.Length < 3)
{
LoggerBundle.Trace("Validation failed: invalid name");
return(StatusCode((Int32)HttpStatusCode.BadRequest));
}
// get data
using (DataContext dc = DataContextFactory.GetInstance())
{
Playlist playlist = dc.SetPlaylists.Include(x => x.CreateUser)
.Include(x => x.PlaylistEntries)
.ThenInclude(x => x.Track)
.Include(x => x.PlaylistEntries)
.ThenInclude(x => x.CreateUser)
.Include(x => x.PlaylistPermissions)
.ThenInclude(x => x.User)
.Where(x => x.CreateUser.UniqueId.Equals(AuthorizedUser.UniqueId))
.FirstOrDefault(x => x.UniqueId.Equals(id));
if (null == playlist)
{
LoggerBundle.Trace($"No playlist found for given id '{id}'");
return(StatusCode((Int32)HttpStatusCode.NotFound));
}
playlist.Name = name;
dc.SaveChanges();
return(Ok(playlist.ToJsonDictionary()));
}
}
catch (Exception ex)
{
return(HandleException(ex));
}
}
private static void Main(String[] args)
{
// mainly for debugging
LoggerBundle.Trace("TEST");
LoggerBundle.Debug("TEST");
LoggerBundle.Inform("TEST");
LoggerBundle.Warn(new Exception());
LoggerBundle.Error(new Exception());
LoggerBundle.Fatal(new Exception());
}
protected override void OnInitialize()
{
LoggerBundle.Debug($"Initializing plugin '{Name}'...");
LoggerBundle.Trace("Requesting config...");
_config = RequestConfig <Config>();
LoggerBundle.Trace("Done");
RegisterAction("include-failed", () => _includeFailed = true);
}
private void HandleStdOutput(DataReceivedEventArgs arguments, Track track)
{
LoggerBundle.Trace($"Processing response of track '{track}'...");
try
{
String output = arguments?.Data?.Trim();
if (String.IsNullOrEmpty(output))
{
return;
}
LoggerBundle.Debug(Logger.DefaultLogFlags & ~LogFlags.SuffixNewLine
, $"Trying to serialize computation output of file '{track}'...");
JsonFingerprint jfp = JsonConvert.DeserializeObject <JsonFingerprint>(output);
LoggerBundle.Debug(Logger.DefaultLogFlags & ~LogFlags.PrefixLoggerType & ~LogFlags.PrefixTimeStamp, "Ok.");
track.LastFingerprintCalculation = DateTime.Now;
track.FingerprintHash = _hasher.Compute(jfp.Fingerprint);
track.FingerprintError = null;
LoggerBundle.Trace($"Fingerprint hash: {track.FingerprintHash} for fingerprint {jfp.Fingerprint}");
using (DataContext dataContext = DataContextFactory.GetInstance())
{
LoggerBundle.Trace($"Checking for duplicates for file '{track}'...");
if (dataContext.SetTracks.AsNoTracking().Any(x => x.FingerprintHash.Equals(track.FingerprintHash)))
{
LoggerBundle.Debug($"File with same fingerprint already in database. Path '{track}' will be skipped");
track.FingerprintError = "duplicate";
}
else
{
LoggerBundle.Trace($"No duplicate found for file '{track}'");
track.Duration = jfp.Duration;
track.Fingerprint = jfp.Fingerprint;
LoggerBundle.Trace($"New meta data duration '{track.Duration}' and fingerprint '{jfp.Fingerprint}'");
}
LoggerBundle.Trace($"Saving file '{track.Path}'...");
dataContext.SetTracks.Attach(track);
dataContext.Entry(track).State = EntityState.Modified;
dataContext.SaveChanges();
LoggerBundle.Debug($"Successfully saved file '{track}'...");
}
}
catch (Exception ex)
{
LoggerBundle.Error(ex);
}
finally
{
_buffer.Remove(track);
}
}
public IActionResult Get(Int32?id)
{
try
{
LoggerBundle.Trace("Registered GET request on FilesController.Get");
if (!IsAuthorized(out IActionResult result))
{
LoggerBundle.Trace("Request not authorized");
return(result);
}
// validate
if (id == null)
{
LoggerBundle.Trace("Validation failed: id is null");
return(StatusCode(StatusCodes.Status400BadRequest));
}
// get track
Track track;
using (DataContext dataContext = DataContextFactory.GetInstance())
{
track = dataContext.SetTracks.FirstOrDefault(x => x.UniqueId.Equals(id));
}
// validate
if (null == track || !System.IO.File.Exists(track.Path))
{
LoggerBundle.Trace($"Track not found for given id '{id}'");
return(StatusCode(StatusCodes.Status404NotFound));
}
FileSystemInfo file = new FileInfo(track.Path);
if (!file.Exists)
{
LoggerBundle.Warn($"File '{track.Path}' not found for given track. Cleanup your database.");
return(StatusCode(StatusCodes.Status404NotFound));
}
// get mime type
if (!new FileExtensionContentTypeProvider().TryGetContentType(file.Name, out String contentType))
{
// default fallback
contentType = $"audio/{file.Extension.Substring(1)}";
}
return(PhysicalFile(file.FullName, contentType));
}
catch (Exception ex)
{
return(HandleException(ex));
}
}
private void HandleResponse(MusicBrainzRecord mbr, JsonMusicBrainzRequest json, DataContext context)
{
LoggerBundle.Trace("Handling response...");
mbr.Disambiguation = json.Disambiguation;
mbr.Length = json.Length;
mbr.Title = json.Title;
mbr.Video = json.Video;
// aliases
List <MusicBrainzAlias> aliases = json.Aliases?.Select(x => MusicBrainzMapper.Map(context, x)).ToList()
?? new List <MusicBrainzAlias>();
IEnumerable <Int32> existingAliasIds =
mbr.MusicBrainzAliasMusicBrainzRecords.Select(x => x.MusicBrainzAliasUniqueId);
IEnumerable <Int32> newAliasIds = aliases.Select(x => x.UniqueId).Except(existingAliasIds).Distinct();
IEnumerable <MusicBrainzAliasMusicBrainzRecord> newAliases = aliases.Where(x => newAliasIds.Contains(x.UniqueId))
.Select(x => MusicBrainzMapper.NewShadow(mbr, x));
mbr.MusicBrainzAliasMusicBrainzRecords.AddRange(newAliases);
// artist credits
List <MusicBrainzArtistCredit> credits = json.ArtistCredit?.Select(x => MusicBrainzMapper.Map(context, x)).ToList()
?? new List <MusicBrainzArtistCredit>();
IEnumerable <Int32> existingCreditIds =
mbr.MusicBrainzArtistCreditMusicBrainzRecords.Select(x => x.MusicBrainzArtistCreditUniqueId);
IEnumerable <Int32> newCreditIds = credits.Select(x => x.UniqueId).Except(existingCreditIds).Distinct();
IEnumerable <MusicBrainzArtistCreditMusicBrainzRecord> newCredits = credits
.Where(x => newCreditIds.Contains(x.UniqueId))
.Select(x => MusicBrainzMapper.NewShadow(mbr, x));
mbr.MusicBrainzArtistCreditMusicBrainzRecords.AddRange(newCredits);
// releases
List <MusicBrainzRelease> releases = json.Releases?.Select(x => MusicBrainzMapper.Map(context, x)).ToList()
?? new List <MusicBrainzRelease>();
IEnumerable <Int32> existingReleaseIds =
mbr.MusicBrainzReleaseMusicBrainzRecords.Select(x => x.MusicBrainzReleaseUniqueId);
IEnumerable <Int32> newReleaseIds = releases.Select(x => x.UniqueId).Except(existingReleaseIds).Distinct();
IEnumerable <MusicBrainzReleaseMusicBrainzRecord> newReleases = releases
.Where(x => newReleaseIds.Contains(x.UniqueId))
.Select(x => MusicBrainzMapper.NewShadow(mbr, x));
mbr.MusicBrainzReleaseMusicBrainzRecords.AddRange(newReleases);
// tags
List <MusicBrainzTag> tags = json.Tags?.Select(x => MusicBrainzMapper.Map(context, x)).ToList()
?? new List <MusicBrainzTag>();
IEnumerable <Int32> existingTagIds = mbr.MusicBrainzTagMusicBrainzRecords.Select(x => x.MusicBrainzTagUniqueId);
IEnumerable <Int32> newTagIds = tags.Select(x => x.UniqueId).Except(existingTagIds).Distinct();
IEnumerable <MusicBrainzTagMusicBrainzRecord> newTags = tags.Where(x => newTagIds.Contains(x.UniqueId))
.Select(x => MusicBrainzMapper.NewShadow(mbr, x));
mbr.MusicBrainzTagMusicBrainzRecords.AddRange(newTags);
}
public Object Post(Double duration, String fingerprint)
{
LoggerBundle.Trace(
$"Received post request for a track with duration '{duration}' and fingerprint {fingerprint}...");
while ((DateTime.Now - _lastRequest).TotalMilliseconds < DELAY_BETWEEN_REQUESTS)
{
Thread.Sleep(1);
}
Dictionary <String, String> values = new Dictionary <String, String>
{
{
"client", _apiKey
}
,
{
"duration", $"{(Int32) duration}"
}
,
{
"fingerprint", fingerprint
}
,
// ReSharper disable once StringLiteralTypo
{
"meta", "recordingids"
}
};
FormUrlEncodedContent content = new FormUrlEncodedContent(values);
_lastRequest = DateTime.Now;
LoggerBundle.Trace("Executing async post...");
Task <HttpResponseMessage> response = _client.PostAsync(API_ENDPOINT, content);
Task <String> responseString = response.Result.Content.ReadAsStringAsync();
LoggerBundle.Trace("Async post done.");
String result = responseString.Result.Trim();
LoggerBundle.Trace($"Result: {result}");
JsonStatus status = JsonConvert.DeserializeObject <JsonStatus>(result);
if (status.Status.ToLower().Trim().Equals("ok"))
{
return(JsonConvert.DeserializeObject <JsonAcoustIdRequest>(result));
}
return(JsonConvert.DeserializeObject <JsonErrorAcoustId>(result));
}
public IActionResult Login([FromBody] AuthenticationModel values)
{
try
{
LoggerBundle.Trace("Registered POST request on LoginsController.Login");
//validate data
String passwordBase64 = values?.Password;
if (String.IsNullOrWhiteSpace(passwordBase64) || String.IsNullOrWhiteSpace(values.Username))
{
LoggerBundle.Trace("Validation failed: empty username or password");
return(StatusCode((Int32)HttpStatusCode.Unauthorized));
}
// hash password
Byte[] bPassword = Convert.FromBase64String(passwordBase64);
String password = Encoding.UTF8.GetString(bPassword);
String passwordHash = new Sha512HashPipe().Process(password);
// normalize username
values.Username = values.Username.Trim();
// check database for given username
User user;
using (DataContext dc = DataContextFactory.GetInstance())
{
user = dc.SetUsers.AsNoTracking().FirstOrDefault(x => x.Username.Equals(values.Username));
}
if (null == user)
{
LoggerBundle.Trace($"No user found for given username '{values.Username}'");
return(StatusCode((Int32)HttpStatusCode.Unauthorized));
}
if (!user.Password.Equals(passwordHash))
{
LoggerBundle.Trace($"Login attempt for user '{user.Username}' failed");
return(StatusCode((Int32)HttpStatusCode.Unauthorized));
}
// prepare token generation
JwtPayload payload = UserJwtPayloadPipe.Process(user);
return(ProcessPayload(payload));
}
catch (Exception ex)
{
LoggerBundle.Error(ex);
return(StatusCode((Int32)HttpStatusCode.Unauthorized));
}
}
public IActionResult Create([FromBody] PlaylistModel model)
{
try
{
LoggerBundle.Trace("Registered PUT request on PlaylistsController.Create");
if (!IsAuthorized(out IActionResult result))
{
LoggerBundle.Trace("Request not authorized");
return(result);
}
// validate
if (model == null)
{
LoggerBundle.Trace("Validation failed: model is null");
return(StatusCode((Int32)HttpStatusCode.BadRequest));
}
String name = model.Name?.Trim();
if (String.IsNullOrWhiteSpace(name) || name.Length < 3)
{
LoggerBundle.Trace("Validation failed: invalid name");
return(StatusCode((Int32)HttpStatusCode.BadRequest));
}
// get data
using (DataContext dc = DataContextFactory.GetInstance())
{
dc.SetUsers.Attach(AuthorizedUser);
Playlist playlist = new Playlist
{
CreateUser = AuthorizedUser
, Name = name
, PlaylistEntries = new List <PlaylistEntry>()
, PlaylistPermissions = new List <PlaylistPermission>()
};
dc.SetPlaylists.Add(playlist);
dc.SaveChanges();
return(Ok(playlist.ToJsonDictionary()));
}
}
catch (Exception ex)
{
return(HandleException(ex));
}
}
public IActionResult Delete(Int32?id)
{
try
{
LoggerBundle.Trace("Registered DELETE request on InviteController.Delete");
if (!IsAuthorized(out IActionResult result, u => u.CanInvite))
{
LoggerBundle.Trace("Request not authorized");
return(result);
}
// validate
if (null == id)
{
LoggerBundle.Trace("Validation failed: id is null");
return(StatusCode((Int32)HttpStatusCode.BadRequest));
}
using (DataContext dc = DataContextFactory.GetInstance())
{
Invite invite = dc.SetInvites.Include(x => x.CreateUser)
.Include(x => x.RegisteredUser)
.Where(x => x.CreateUser.CanInvite)
.Where(x => x.CreateUser.UniqueId.Equals(AuthorizedUser.UniqueId))
.FirstOrDefault(x => x.UniqueId.Equals(id));
if (null == invite)
{
LoggerBundle.Trace($"No invite found for given id '{id}'");
return(StatusCode((Int32)HttpStatusCode.NotFound));
}
if (null != invite.RegisteredUser)
{
LoggerBundle.Trace($"Invite with id '{id}' has already been used and can therefor not be deleted");
return(StatusCode((Int32)HttpStatusCode.Conflict));
}
dc.SetInvites.Remove(invite);
dc.SaveChanges();
return(Ok());
}
}
catch (Exception ex)
{
return(HandleException(ex));
}
}
public IActionResult GetBySearchQuery(String query
, [FromQuery(Name = "ps")] Int32 pageSize = 50
, [FromQuery(Name = "p")] Int32 page = 0)
{
try
{
LoggerBundle.Trace("Registered GET request on RecordsController.GetBySearchQuery");
if (!IsAuthorized(out IActionResult result))
{
LoggerBundle.Trace("Request not authorized");
return(result);
}
// validate
if (String.IsNullOrWhiteSpace(query))
{
LoggerBundle.Trace("Validation failed: empty query");
return(StatusCode((Int32)HttpStatusCode.BadRequest));
}
NormalizePageSize(ref pageSize);
query = query.Trim();
// get data
using (DataContext dc = DataContextFactory.GetInstance())
{
return(Ok(dc.SetMusicBrainzRecords.AsNoTracking()
.Where(x => null != x.Title)
.Where(x => x.Title.Contains(query))
.Select(x => x.Title)
.OrderBy(x => x)
.Distinct()
.Skip(page * pageSize)
.Take(pageSize)
.Select(x => new Dictionary <String, Object>
{
{
"Title", x
}
})
.ToList()));
}
}
catch (Exception ex)
{
return(HandleException(ex));
}
}
public IActionResult GetById(Int32?id)
{
try
{
LoggerBundle.Trace("Registered GET request on PlaylistsController.GetById");
if (!IsAuthorized(out IActionResult result))
{
LoggerBundle.Trace("Request not authorized");
return(result);
}
// validate
if (id == null)
{
LoggerBundle.Trace("Validation failed: id is null");
return(StatusCode((Int32)HttpStatusCode.BadRequest));
}
// get data
using (DataContext dc = DataContextFactory.GetInstance())
{
Playlist playlist = dc.SetPlaylists.AsNoTracking()
.Include(x => x.CreateUser)
.Include(x => x.PlaylistEntries)
.ThenInclude(x => x.Track)
.Include(x => x.PlaylistEntries)
.ThenInclude(x => x.CreateUser)
.Include(x => x.PlaylistPermissions)
.ThenInclude(x => x.User)
.Where(x => x.CreateUser.UniqueId.Equals(AuthorizedUser.UniqueId) ||
x.PlaylistPermissions.Any(y => y.User.UniqueId.Equals(AuthorizedUser.UniqueId)))
.FirstOrDefault(x => x.UniqueId.Equals(id));
if (null == playlist)
{
LoggerBundle.Trace($"No playlist found for given id '{id}'");
return(StatusCode((Int32)HttpStatusCode.NotFound));
}
return(Ok(playlist.ToJsonDictionary()));
}
}
catch (Exception ex)
{
return(HandleException(ex));
}
}
protected override ProcessPipe <String, String> GetExecuteLogPipe()
{
String logDir = Path.GetDirectoryName(LogPath);
if (!Directory.Exists(logDir))
{
LoggerBundle.Trace(DefaultLogFlags & ~LogFlags.SuffixNewLine
, $"Creating directory '{logDir}' for file logger of type '{Type}'...");
Directory.CreateDirectory(logDir);
LoggerBundle.Trace(DefaultLogFlags & ~LogFlags.PrefixLoggerType & ~LogFlags.PrefixTimeStamp, "Ok.");
}
FileStream fileStream = File.Open(LogPath, FileMode.Append, FileAccess.Write, FileShare.Read);
StreamWriter writer = new StreamWriter(fileStream, Encoding.UTF8);
return(new WriterPipe(writer));
}
public static Boolean Save <T>(T obj, String path) where T : class
{
if (null == obj)
{
LoggerBundle.Error(new ArgumentNullException(nameof(obj)));
return(false);
}
if (null == path)
{
LoggerBundle.Error(new ArgumentNullException(nameof(path)));
return(false);
}
if (File.Exists(path))
{
LoggerBundle.Error(new PathOccupiedException());
return(false);
}
try
{
LoggerBundle.Trace(Logger.DefaultLogFlags & ~LogFlags.SuffixNewLine
, $"Trying to serialize obj for file '{path}'...");
String text = JsonConvert.SerializeObject(obj);
LoggerBundle.Trace(Logger.DefaultLogFlags & ~LogFlags.PrefixLoggerType & ~LogFlags.PrefixTimeStamp, "Ok.");
LoggerBundle.Trace($"Serialized object for file '{path}' is '{text}'");
String pathRoot = Path.GetDirectoryName(path);
if (!Directory.Exists(pathRoot))
{
LoggerBundle.Trace(Logger.DefaultLogFlags & ~LogFlags.SuffixNewLine
, $"Directory '{pathRoot}' does not exist. Trying to create it...");
Directory.CreateDirectory(pathRoot);
LoggerBundle.Trace(Logger.DefaultLogFlags & ~LogFlags.PrefixLoggerType & ~LogFlags.PrefixTimeStamp, "Ok.");
}
LoggerBundle.Trace(Logger.DefaultLogFlags & ~LogFlags.SuffixNewLine, $"Writing object to file '{path}'...");
File.WriteAllText(path, text);
LoggerBundle.Trace(Logger.DefaultLogFlags & ~LogFlags.PrefixLoggerType & ~LogFlags.PrefixTimeStamp, "Ok.");
return(true);
}
catch (Exception ex)
{
LoggerBundle.Error(ex);
return(false);
}
}
public Object Get(String id)
{
LoggerBundle.Debug($"Get request for id '{id}'...");
while ((DateTime.Now - _lastRequest).TotalMilliseconds < DELAY_BETWEEN_REQUESTS)
{
Thread.Sleep(1);
}
String url = String.Format(URI_API_MUSICBRAINZ, id ?? String.Empty);
LoggerBundle.Trace($"Posting to '{url}'");
Assembly coreAssembly = typeof(PluginBase).Assembly;
Version coreVersion = coreAssembly.GetName().Version;
HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Get, url);
String userAgent = $"Mux/{coreVersion} ( mail @fooo.ooo ) - Instance {_guid}";
req.Headers.Add("User-Agent", userAgent);
LoggerBundle.Trace($"User-Agent: {userAgent}");
_lastRequest = DateTime.Now;
LoggerBundle.Trace(Logger.DefaultLogFlags & ~LogFlags.SuffixNewLine, "Sending async request...");
Task <HttpResponseMessage> response = _client.SendAsync(req);
LoggerBundle.Trace(Logger.DefaultLogFlags & ~LogFlags.PrefixTimeStamp & ~LogFlags.PrefixLoggerType, "Ok.");
Task <String> responseString = response.Result.Content.ReadAsStringAsync();
String responseBody = responseString.Result.Trim();
LoggerBundle.Trace($"Response: {responseBody}");
LoggerBundle.Trace(Logger.DefaultLogFlags & ~LogFlags.SuffixNewLine, "Trying to deserialize object...");
JsonErrorMusicBrainz status = JsonConvert.DeserializeObject <JsonErrorMusicBrainz>(responseBody);
LoggerBundle.Trace(Logger.DefaultLogFlags & ~LogFlags.PrefixTimeStamp & ~LogFlags.PrefixLoggerType, "Ok.");
if (null == status.Error)
{
// no error found
return(JsonConvert.DeserializeObject <JsonMusicBrainzRequest>(responseBody));
}
return(status);
}
static DataController()
{
new List <String>
{
Location.ApplicationDataDirectoryPath
, Location.LogsDirectoryPath
, Location.PluginsDirectoryPath
}.Where(x => !Directory.Exists(x))
.ToList()
.ForEach(x =>
{
LoggerBundle.Trace(Logger.DefaultLogFlags & ~LogFlags.SuffixNewLine
, $"Trying to create directory '{x}'...");
Directory.CreateDirectory(x);
LoggerBundle.Trace(Logger.DefaultLogFlags & ~LogFlags.PrefixLoggerType & ~LogFlags.PrefixTimeStamp, "Ok.");
});
}
public IActionResult Delete(Int32?id)
{
try
{
LoggerBundle.Trace("Registered DELETE request on PlaylistsController.Delete");
if (!IsAuthorized(out IActionResult result))
{
LoggerBundle.Trace("Request not authorized");
return(result);
}
// validate
if (!id.HasValue)
{
LoggerBundle.Trace("Validation failed: id is null");
return(StatusCode((Int32)HttpStatusCode.BadRequest));
}
// get data
using (DataContext dc = DataContextFactory.GetInstance())
{
Playlist playlist = dc.SetPlaylists.Include(x => x.PlaylistEntries)
.Include(x => x.PlaylistPermissions)
.Where(x => x.CreateUser.UniqueId.Equals(AuthorizedUser.UniqueId))
.FirstOrDefault(x => x.UniqueId.Equals(id));
if (null == playlist)
{
LoggerBundle.Trace($"No playlist found for given id '{id}'");
return(StatusCode((Int32)HttpStatusCode.NotFound));
}
dc.SetPlaylistEntries.RemoveRange(playlist.PlaylistEntries);
dc.SetPlaylistPermissions.RemoveRange(playlist.PlaylistPermissions);
dc.SetPlaylists.Remove(playlist);
dc.SaveChanges();
return(Ok());
}
}
catch (Exception ex)
{
return(HandleException(ex));
}
}