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);
                }
            }
        }
Beispiel #2
0
        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();
            }
        }
Beispiel #3
0
        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));
        }
Beispiel #7
0
 /// <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);
     }
 }
Beispiel #8
0
 /// <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);
     }
 }
Beispiel #9
0
 /// <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);
     }
 }
Beispiel #10
0
 /// <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);
     }
 }
Beispiel #11
0
 /// <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);
     }
 }
Beispiel #12
0
 /// <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);
     }
 }
Beispiel #13
0
        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);
        }
Beispiel #14
0
        /// <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);
        }
Beispiel #16
0
        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));
            }
        }
Beispiel #18
0
 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;
 }
Beispiel #20
0
 public AddingLibraryItemToPlaylistResultEventArgs(bool result, MultimediaItem multimedia)
 {
     this.Result     = result;
     this.Multimedia = multimedia;
 }
Beispiel #21
0
 public PlayerUpdateReceivedEventArgs(MultimediaItem multimedia, int playbackPosition, bool playing)
 {
     this.Multimedia       = multimedia;
     this.PlaybackPosition = playbackPosition;
     this.Playing          = playing;
 }
Beispiel #22
0
 public PlayerStateChangedEventArgs(MultimediaItem multimedia, int playbackPosition, bool playing)
 {
     this.Multimedia       = multimedia;
     this.PlaybackPosition = playbackPosition;
     this.Playing          = playing;
 }
Beispiel #23
0
        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);
        }
Beispiel #24
0
 public MultimediaViewModel(MultimediaItem multimedia)
 {
     this.multimedia = multimedia;
 }
Beispiel #25
0
        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);
        }
Beispiel #26
0
 public ItemAddedEventArgs(bool success, MultimediaItem multimedia)
 {
     this.Success    = success;
     this.Multimedia = multimedia;
 }
Beispiel #27
0
        public async Task <MultimediaItem> Add(MultimediaItem item)
        {
            var newItem = await _dbContext.MultimediaItems.AddAsync(item);

            return(newItem.Entity);
        }