static void Main(string[] args)
{
// Create a Media Database based on the .csv file
MediaDatabase database = new MediaDatabase("Media_Library_Database.csv");
Console.WriteLine("Welcome to the Multi-Media Library archive manager");
while (true)
{
// Ask user for media type
Console.WriteLine("\nPlease, select media type you want to filter on: [A]lbum | [M]ovie | [B]ook | [V]ideogame | [E]xit");
string type = Console.ReadLine();
string headers = MultimediaItem.GetHeaders(type);
// When user specifies a type that doesn't exist, exit the application
if (headers == null)
{
return;
}
// Ask user for property to order elements by
Console.WriteLine(headers);
string sortingProperty = Console.ReadLine();
// Get filtered and sorted items from our database
IEnumerable <MultimediaItem> records = database.GetElements(type, sortingProperty);
// Print them on screen
foreach (MultimediaItem item in records)
{
Console.WriteLine(item.DetailedInformation);
}
}
}
private void OnPlayerStateUpdate(object sender, PlayerStateChangedEventArgs eventArgs)
{
NotifyPropertyChanged("MultimediaName");
NotifyPropertyChanged("MultimediaLength");
NotifyPropertyChanged("Playing");
NotifyPropertyChanged("PlaybackPosition");
NotifyPropertyChanged("PlaybackTime");
MultimediaItem multimedia = eventArgs.Multimedia;
if (eventArgs.Multimedia != null)
{
this.millisLength = (long)multimedia.Length * 1000;
long millisEstimatedLength = millisLength - (eventArgs.PlaybackPosition * 1000);
int millisStep = 1000 / 60;
if (playbackUpdater != null)
{
playbackUpdater.Cancel();
}
playbackUpdater = new CountDownTimer(new DispatcherMessageQueue(), millisEstimatedLength, millisStep);
playbackUpdater.Tick += OnUpdaterTick;
playbackUpdater.Finish += OnUpdaterFinish;
playbackUpdater.Start();
}
}
public AddLibraryItemToPlaylistResultData Transform(string input)
{
JObject rootNode = JObject.Parse(input);
bool result = rootNode["result"].ToObject <bool>();
if (!result)
{
return(new AddLibraryItemToPlaylistResultData(result, null));
}
else
{
JObject libraryItemNode = rootNode["multimedia"] as JObject;
long id = libraryItemNode["id"].ToObject <long>();
LibraryItemType type = LibraryItemTypeParser.Parse(libraryItemNode["type"].ToObject <string>());
if (type != LibraryItemType.Multimedia)
{
throw new ArgumentException("Only MULTIMEDIA type is supported for now.");
}
string name = libraryItemNode["name"].ToObject <string>();
int length = libraryItemNode["length"].ToObject <int>();
MultimediaItem multimedia = new MultimediaItem(id, name, length);
return(new AddLibraryItemToPlaylistResultData(result, multimedia));
}
}
private void OnAddMultimediaToPlaylistResult(AddLibraryItemToPlaylistResultData result)
{
bool success = result.Success;
MultimediaItem multimedia = (MultimediaItem)result.LibraryItem;
AddingLibraryItemToPlaylistResultEventArgs eventArgs = new AddingLibraryItemToPlaylistResultEventArgs(success, multimedia);
AddingLibraryItemToPlaylistResult(this, eventArgs);
}
private void OnPlayerStateReceived(GetPlayerStateResultData result)
{
MultimediaItem multimedia = result.Multimedia;
int playbackPosition = result.PlaybackPosition;
bool playing = result.Playing;
PlayerUpdateReceivedEventArgs eventArgs = new PlayerUpdateReceivedEventArgs(multimedia, playbackPosition, playing);
PlayerUpdateReceived(this, eventArgs);
}
public void RequestPlayerUpdate()
{
MultimediaItem multimedia = new MultimediaItem(1, "Mock", 13);
int playbackPosition = 5;
bool playing = true;
PlayerUpdateReceivedEventArgs eventArgs = new PlayerUpdateReceivedEventArgs(multimedia, playbackPosition, playing);
messageQueue.Post(() => PlayerUpdateReceived(this, eventArgs));
}
/// <summary>
/// Checks how well the handler supports multimedia content of a given type.
/// </summary>
/// <param name="Item">Multimedia item.</param>
/// <returns>How well the handler supports the content.</returns>
public override Grade Supports(MultimediaItem Item)
{
if (youTubeLink.IsMatch(Item.Url) || youTubeLink2.IsMatch(Item.Url))
{
return(Grade.Ok);
}
else
{
return(Grade.NotAtAll);
}
}
/// <summary>
/// Checks how well the handler supports multimedia content of a given type.
/// </summary>
/// <param name="Item">Multimedia item.</param>
/// <returns>How well the handler supports the content.</returns>
public override Grade Supports(MultimediaItem Item)
{
if (string.Compare(Item.Url, "ToC", true) == 0)
{
return(Grade.Excellent);
}
else
{
return(Grade.NotAtAll);
}
}
/// <summary>
/// Checks how well the handler supports multimedia content of a given type.
/// </summary>
/// <param name="Item">Multimedia item.</param>
/// <returns>How well the handler supports the content.</returns>
public override Grade Supports(MultimediaItem Item)
{
if (Item.ContentType.StartsWith("image/"))
{
return(Grade.Ok);
}
else
{
return(Grade.Barely);
}
}
/// <summary>
/// Checks how well the handler supports multimedia content of a given type.
/// </summary>
/// <param name="Item">Multimedia item.</param>
/// <returns>How well the handler supports the content.</returns>
public override Grade Supports(MultimediaItem Item)
{
if (Item.ContentType.StartsWith("video/"))
{
return(Grade.Ok);
}
else
{
return(Grade.NotAtAll);
}
}
/// <summary>
/// Checks how well the handler supports multimedia content of a given type.
/// </summary>
/// <param name="Item">Multimedia item.</param>
/// <returns>How well the handler supports the content.</returns>
public override Grade Supports(MultimediaItem Item)
{
if (Item.Url.EndsWith("/") || Item.ContentType.StartsWith("text/"))
{
return(Grade.Ok);
}
else
{
return(Grade.Barely);
}
}
/// <summary>
/// Checks how well the handler supports multimedia content of a given type.
/// </summary>
/// <param name="Item">Multimedia item.</param>
/// <returns>How well the handler supports the content.</returns>
public override Grade Supports(MultimediaItem Item)
{
if (Item.Document != null && !string.IsNullOrEmpty(Item.Document.FileName) &&
Item.Url.IndexOf(':') < 0 && Item.ContentType == "text/markdown")
{
return(Grade.Excellent);
}
else
{
return(Grade.NotAtAll);
}
}
public async Task <MultimediaItem> Edit(MultimediaItem editedItem)
{
var existedItem = await GetWithoutIncludes(editedItem.Id);
existedItem.Type = editedItem.Type;
existedItem.Name = editedItem.Name;
existedItem.Url = editedItem.Url;
_dbContext.MultimediaItems.Update(existedItem);
return(existedItem);
}
/// <summary>
/// Gets the best multimedia handler for a set of URLs or file names.
/// </summary>
/// <param name="URLs">Set of URLs, or file names.</param>
/// <returns>Best multimedia handler.</returns>
public static IMultimediaContent GetMultimediaHandler(params string[] URLs)
{
int i, c = URLs.Length;
MultimediaItem[] Items = new MultimediaItem[c];
for (i = 0; i < c; i++)
{
Items[i] = new MultimediaItem(null, URLs[i], string.Empty, null, null);
}
return(GetMultimediaHandler(Items));
}
// private MultimediaItem _multimediaitem;
/// <summary>
/// This is the constructor, called when somebody writes "new MediaDatabase(path)"
/// </summary>
public MultimediaItem[] GetMediaDatabase()
{
string databasePath = "Media_Library_Database.csv";
// Read file contents (as an entire string)
string fileContent = LoadDatabaseFromDisk(databasePath);
int i = 0;
using (StreamReader sr = new StreamReader(databasePath))
{
string currentLine;
// Create empty array
var lines = File.ReadLines(databasePath);
_mediaDatabase = new MultimediaItem[lines.Count()];
// currentLine will be null when the StreamReader reaches the end of file
while ((currentLine = sr.ReadLine()) != null)
{
// Search, case insensitive, if the currentLine contains the searched keyword
if (currentLine.IndexOf(";", StringComparison.CurrentCultureIgnoreCase) >= 0)
{
// Console.WriteLine(currentLine);
// Create each record, one per line that exist on the file
//for (int i = 0; i < lines.Count(); i++)
//mediaarray.Append(MultimediaItem.ParseMultimediaItem(currentLine).Title);
//mediaarray.Append(MultimediaItem.ParseMultimediaItem(currentLine).Year.ToString());
//mediaarray.Append(MultimediaItem.ParseMultimediaItem(currentLine).IsLent.ToString());
//mediaarray.Append(MultimediaItem.ParseMultimediaItem(currentLine).DetailedInformation);
//// _mediaDatabase.Append(MultimediaItem.ParseMultimediaItem();
//// i++;
//_mediaDatabase.Append(mediaarray);
_mediaDatabase[i] = MultimediaItem.ParseMultimediaItem(currentLine);
_mediaDatabase.Append(_mediaDatabase[i]);
i++;
}
}
}
// Split the string it into single lines
//string[] records = fileContent.Split("\r\n", StringSplitOptions.RemoveEmptyEntries);
//// Create empty array
//_mediaDatabase = new MultimediaItem[records.Length];
//// Create each record, one per line that exist on the file
//for (int i = 0; i < records.Length; i++)
// _mediaDatabase[i] = MultimediaItem.ParseMultimediaItem(records[i]);
return(_mediaDatabase);
}
public GetPlaylistResultData Transform(string input)
{
JObject rootNode = JObject.Parse(input);
JArray playlistArray = rootNode["playlist"] as JArray;
IList <MultimediaItem> playlist = new List <MultimediaItem>();
MultimediaJsonDecoder decoder = new MultimediaJsonDecoder();
foreach (JObject entry in playlistArray)
{
MultimediaItem multimedia = decoder.Transform(entry);
playlist.Add(multimedia);
}
return(new GetPlaylistResultData(playlist));
}
public GetPlayerStateResultData Transform(string input)
{
JObject rootNode = JObject.Parse(input);
MultimediaJsonDecoder multimediaJsonDecoder = new MultimediaJsonDecoder();
if (rootNode["multimedia"].ToString() == JsonValues.Null)
{
return(new GetPlayerStateResultData(null, 0, false));
}
else
{
MultimediaItem multimedia = multimediaJsonDecoder.Transform(rootNode["multimedia"] as JObject);
int playbackPosition = rootNode["playbackPosition"].ToObject <int>();
bool playing = rootNode["playing"].ToObject <bool>();
return(new GetPlayerStateResultData(multimedia, playbackPosition, playing));
}
}
private void UpdatePlayerState(MultimediaItem multimedia, int playbackPosition, bool playing)
{
}
public GetPlayerStateResultData(MultimediaItem multimedia, int playbackPosition, bool playing)
{
this.Multimedia = multimedia;
this.PlaybackPosition = playbackPosition;
this.Playing = playing;
}
public AddingLibraryItemToPlaylistResultEventArgs(bool result, MultimediaItem multimedia)
{
this.Result = result;
this.Multimedia = multimedia;
}
public PlayerUpdateReceivedEventArgs(MultimediaItem multimedia, int playbackPosition, bool playing)
{
this.Multimedia = multimedia;
this.PlaybackPosition = playbackPosition;
this.Playing = playing;
}
public PlayerStateChangedEventArgs(MultimediaItem multimedia, int playbackPosition, bool playing)
{
this.Multimedia = multimedia;
this.PlaybackPosition = playbackPosition;
this.Playing = playing;
}
private MarkdownDocument GetMarkdown(MultimediaItem Item, string ParentURL)
{
int i = Item.Url.IndexOf('?');
string Query;
string FileName;
if (i < 0)
{
Query = null;
FileName = Item.Url;
}
else
{
Query = Item.Url.Substring(i + 1);
FileName = Item.Url.Substring(0, i);
}
if (!string.IsNullOrEmpty(ParentURL))
{
if (Uri.TryCreate(new Uri(ParentURL), FileName, out Uri NewUri))
{
ParentURL = NewUri.ToString();
}
}
FileName = Path.Combine(Path.GetDirectoryName(Item.Document.FileName), FileName);
if (!string.IsNullOrEmpty(Query))
{
Variables Variables = Item.Document.Settings.Variables;
string Value;
if (Variables != null)
{
foreach (string Part in Query.Split('&'))
{
i = Part.IndexOf('=');
if (i < 0)
{
Variables[Part] = string.Empty;
}
else
{
Value = Part.Substring(i + 1);
if (double.TryParse(Value.Replace(".", System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator), out double d))
{
Variables[Part.Substring(0, i)] = d;
}
else if (bool.TryParse(Value, out bool b))
{
Variables[Part.Substring(0, i)] = b;
}
else
{
Variables[Part.Substring(0, i)] = Value;
}
}
}
}
}
string MarkdownText = File.ReadAllText(FileName);
MarkdownDocument Markdown = new MarkdownDocument(MarkdownText, Item.Document.Settings, FileName, string.Empty, ParentURL)
{
Master = Item.Document
};
MarkdownDocument Loop = Item.Document;
while (Loop != null)
{
if (Loop.FileName == FileName)
{
throw new Exception("Circular reference detected.");
}
Loop = Loop.Master;
}
return(Markdown);
}
public MultimediaViewModel(MultimediaItem multimedia)
{
this.multimedia = multimedia;
}
private MarkdownDocument GetMarkdown(MultimediaItem Item, string ParentURL)
{
int i = Item.Url.IndexOf('?');
string Query;
string FileName;
if (i < 0)
{
Query = null;
FileName = Item.Url;
}
else
{
Query = Item.Url.Substring(i + 1);
FileName = Item.Url.Substring(0, i);
}
if (!string.IsNullOrEmpty(ParentURL))
{
if (Uri.TryCreate(new Uri(ParentURL), FileName, out Uri NewUri))
{
ParentURL = NewUri.ToString();
}
}
FileName = Item.Document.Settings.GetFileName(Item.Document.FileName, FileName);
if (!string.IsNullOrEmpty(Query))
{
Variables Variables = Item.Document.Settings.Variables;
string Value;
if (!(Variables is null))
{
foreach (string Part in Query.Split('&'))
{
i = Part.IndexOf('=');
if (i < 0)
{
Variables[Part] = string.Empty;
}
else
{
Value = Part.Substring(i + 1);
if (CommonTypes.TryParse(Value, out double d))
{
Variables[Part.Substring(0, i)] = d;
}
else if (bool.TryParse(Value, out bool b))
{
Variables[Part.Substring(0, i)] = b;
}
else
{
Variables[Part.Substring(0, i)] = Value;
}
}
}
}
}
string MarkdownText = File.ReadAllText(FileName);
MarkdownDocument Markdown = new MarkdownDocument(MarkdownText, Item.Document.Settings, FileName, string.Empty, ParentURL)
{
Master = Item.Document
};
MarkdownDocument Loop = Item.Document;
while (!(Loop is null))
{
if (Loop.FileName == FileName)
{
throw new Exception("Circular reference detected.");
}
MarkdownDocument.CopyMetaDataTags(Loop, Markdown);
Loop = Loop.Master;
}
return(Markdown);
}
public ItemAddedEventArgs(bool success, MultimediaItem multimedia)
{
this.Success = success;
this.Multimedia = multimedia;
}
public async Task <MultimediaItem> Add(MultimediaItem item)
{
var newItem = await _dbContext.MultimediaItems.AddAsync(item);
return(newItem.Entity);
}
