Example #1
0
        private async Task <string> GetReleaseIdFromReleaseGroupId(string releaseGroupId, CancellationToken cancellationToken)
        {
            var url = "/ws/2/release?release-group=" + releaseGroupId.ToString(CultureInfo.InvariantCulture);

            using (var response = await GetMusicBrainzResponse(url, cancellationToken).ConfigureAwait(false))
                using (var stream = response.Content)
                    using (var oReader = new StreamReader(stream, Encoding.UTF8))
                    {
                        var settings = new XmlReaderSettings()
                        {
                            ValidationType  = ValidationType.None,
                            CheckCharacters = false,
                            IgnoreProcessingInstructions = true,
                            IgnoreComments = true
                        };

                        using (var reader = XmlReader.Create(oReader, settings))
                        {
                            var result = ReleaseResult.Parse(reader).FirstOrDefault();

                            if (result != null)
                            {
                                return(result.ReleaseId);
                            }
                        }
                    }

            return(null);
        }
Example #2
0
        private async Task <string> GetReleaseIdFromReleaseGroupId(string releaseGroupId, CancellationToken cancellationToken)
        {
            var url = string.Format("/ws/2/release?release-group={0}", releaseGroupId);

            using (var response = await GetMusicBrainzResponse(url, true, true, cancellationToken).ConfigureAwait(false))
            {
                using (var stream = response.Content)
                {
                    using (var oReader = new StreamReader(stream, Encoding.UTF8))
                    {
                        var settings = _xmlSettings.Create(false);

                        settings.CheckCharacters = false;
                        settings.IgnoreProcessingInstructions = true;
                        settings.IgnoreComments = true;

                        using (var reader = XmlReader.Create(oReader, settings))
                        {
                            var result = ReleaseResult.Parse(reader).FirstOrDefault();

                            if (result != null)
                            {
                                return(result.ReleaseId);
                            }
                        }
                    }
                }
            }

            return(null);
        }
Example #3
0
        private async Task <ReleaseResult> GetReleaseResultByArtistName(string albumName, string artistName, CancellationToken cancellationToken)
        {
            var url = string.Format("/ws/2/release/?query=\"{0}\" AND artist:\"{1}\"",
                                    WebUtility.UrlEncode(albumName),
                                    WebUtility.UrlEncode(artistName));

            using (var response = await GetMusicBrainzResponse(url, true, cancellationToken).ConfigureAwait(false))
            {
                using (var stream = response.Content)
                {
                    using (var oReader = new StreamReader(stream, Encoding.UTF8))
                    {
                        var settings = _xmlSettings.Create(false);

                        settings.CheckCharacters = false;
                        settings.IgnoreProcessingInstructions = true;
                        settings.IgnoreComments = true;

                        using (var reader = XmlReader.Create(oReader, settings))
                        {
                            return(ReleaseResult.Parse(reader).FirstOrDefault());
                        }
                    }
                }
            }
        }
Example #4
0
        /// <summary>
        /// Example for performing  release payment request.
        /// </summary>
        public void Release()
        {
            //Reserving amount in order to release method example could be successful
            PaymentResult paymentResult = ReserveAmount(Amount.Get(2190.00, Currency.EUR), AuthType.payment);
            //Transaction ID is returned from the gateway when payment request was successful
            string transactionId = paymentResult.Payment.TransactionId;

            //initialize release request class
            ReleaseRequest releaseRequest = new ReleaseRequest
            {
                PaymentId = transactionId
            };

            //call release method
            ReleaseResult releaseResult = _api.Release(releaseRequest);

            //Result property contains information if the request was successful or not
            if (releaseResult.Result == Result.Success)
            {
                //release was successful
                Transaction transaction = releaseResult.Payment;
            }
            else
            {
                //release unsuccessful
                //error messages contain information about what went wrong
                string errorMerchantMessage = releaseResult.ResultMerchantMessage;
                string errorMessage         = releaseResult.ResultMessage;
            }
        }
Example #5
0
        private List <RemoteSearchResult> GetResultsFromResponse(Stream stream, bool isSearch)
        {
            using (var oReader = new StreamReader(stream, Encoding.UTF8))
            {
                var settings = _xmlSettings.Create(false);
                settings.CheckCharacters = false;
                settings.IgnoreProcessingInstructions = true;
                settings.IgnoreComments = true;

                using (var reader = XmlReader.Create(oReader, settings))
                {
                    var results = isSearch ? ReleaseResult.ParseSearch(reader) : ReleaseResult.ParseReleaseList(reader);
                    return(results.Select(i =>
                    {
                        var result = new RemoteSearchResult
                        {
                            Name = i.Title,
                            ProductionYear = i.Year,
                            Artists = i.Artists.ToArray()
                        };
                        result.SetProviderId("IMVDb", i.ReleaseId);
                        return result;
                    }).ToList());
                }
            }
        }
        private ReleaseResult GetReleaseResult(XmlDocument doc)
        {
            var ns = new XmlNamespaceManager(doc.NameTable);

            ns.AddNamespace("mb", "http://musicbrainz.org/ns/mmd-2.0#");

            var result = new ReleaseResult
            {
            };

            var releaseIdNode = doc.SelectSingleNode("//mb:release-list/mb:release/@id", ns);

            if (releaseIdNode != null)
            {
                result.ReleaseId = releaseIdNode.Value;
            }

            var releaseGroupIdNode = doc.SelectSingleNode("//mb:release-list/mb:release/mb:release-group/@id", ns);

            if (releaseGroupIdNode != null)
            {
                result.ReleaseGroupId = releaseGroupIdNode.Value;
            }

            return(result);
        }
 /// <summary>
 /// For every document, this method will be called after all pages have been sent to the script.
 /// The scripts usually perform the necessary cleanup based on current settings and the actual release conditions.
 /// </summary>
 public void EndDocument(IDocument doc, object handle, ReleaseResult result)
 {
     /// The handle should always indicate whether or not the script created the document folder from scratch
     if (result != ReleaseResult.Succeeded && (bool)handle)
     {
         Directory.Delete(m_DocFolder);
     }
 }
 /// <summary>
 /// This method will be called after all documents have been sent to the script.
 /// The scripts usually perform the necessary cleanup based on current settings
 /// and the actual release conditions.
 /// </summary>
 public void EndBatch(IBatch batch, object handle, ReleaseResult result)
 {
     /// The handle should always indicate whether or not the script created the batch folder from scratch
     if (result != ReleaseResult.Succeeded && (bool)handle)
     {
         Directory.Delete(m_BatchFolder);
     }
 }
        private async Task <ReleaseResult> GetReleaseResultByArtistName(string albumName, string artistName, CancellationToken cancellationToken)
        {
            var url = string.Format("/ws/2/release/?query=\"{0}\" AND artist:\"{1}\"",
                                    WebUtility.UrlEncode(albumName),
                                    WebUtility.UrlEncode(artistName));

            var doc = await GetMusicBrainzResponse(url, true, cancellationToken).ConfigureAwait(false);

            return(ReleaseResult.Parse(doc, 1).FirstOrDefault());
        }
        private IEnumerable <RemoteSearchResult> GetResultsFromResponse(Stream stream)
        {
            using (var oReader = new StreamReader(stream, Encoding.UTF8))
            {
                var settings = new XmlReaderSettings()
                {
                    ValidationType  = ValidationType.None,
                    CheckCharacters = false,
                    IgnoreProcessingInstructions = true,
                    IgnoreComments = true
                };

                using (var reader = XmlReader.Create(oReader, settings))
                {
                    var results = ReleaseResult.Parse(reader);

                    return(results.Select(i =>
                    {
                        var result = new RemoteSearchResult
                        {
                            Name = i.Title,
                            ProductionYear = i.Year
                        };

                        if (i.Artists.Count > 0)
                        {
                            result.AlbumArtist = new RemoteSearchResult
                            {
                                SearchProviderName = Name,
                                Name = i.Artists[0].Item1
                            };

                            var artistId = i.Artists[0].Item2;
                            if (artistId != null)
                            {
                                result.AlbumArtist.SetProviderId(MetadataProvider.MusicBrainzArtist, artistId);
                            }
                        }

                        if (!string.IsNullOrWhiteSpace(i.ReleaseId))
                        {
                            result.SetProviderId(MetadataProvider.MusicBrainzAlbum, i.ReleaseId);
                        }

                        if (!string.IsNullOrWhiteSpace(i.ReleaseGroupId))
                        {
                            result.SetProviderId(MetadataProvider.MusicBrainzReleaseGroup, i.ReleaseGroupId);
                        }

                        return result;
                    }));
                }
            }
        }
        /// <summary>
        /// Creates the index file since we have the path to all images
        /// </summary>
        public void EndDocument(IDocument doc, object handle, ReleaseResult result)
        {
            /// The handle should always indicate whether or not the script created the document folder from scratch
            if (result != ReleaseResult.Succeeded && (bool)handle)
            {
                Directory.Delete(m_DocFolder);
            }

            index.CreateIndex(doc, m_FilenameReleaseData, Path.Combine(m_BatchFolder, m_IndexFileName));

            m_FilenameReleaseData.Clear();
        }
Example #12
0
        private List <RemoteSearchResult> GetResultsFromResponse(Stream stream)
        {
            using (var oReader = new StreamReader(stream, Encoding.UTF8))
            {
                var settings = _xmlSettings.Create(false);

                settings.CheckCharacters = false;
                settings.IgnoreProcessingInstructions = true;
                settings.IgnoreComments = true;

                using (var reader = XmlReader.Create(oReader, settings))
                {
                    var results = ReleaseResult.Parse(reader);

                    return(results.Select(i =>
                    {
                        var result = new RemoteSearchResult
                        {
                            Name = i.Title,
                            ProductionYear = i.Year
                        };

                        if (i.Artists.Count > 0)
                        {
                            result.AlbumArtist = new RemoteSearchResult
                            {
                                SearchProviderName = Name,
                                Name = i.Artists[0].Item1
                            };

                            result.AlbumArtist.SetProviderId(MetadataProviders.MusicBrainzArtist, i.Artists[0].Item2);
                        }

                        if (!string.IsNullOrWhiteSpace(i.ReleaseId))
                        {
                            result.SetProviderId(MetadataProviders.MusicBrainzAlbum, i.ReleaseId);
                        }
                        if (!string.IsNullOrWhiteSpace(i.ReleaseGroupId))
                        {
                            result.SetProviderId(MetadataProviders.MusicBrainzReleaseGroup, i.ReleaseGroupId);
                        }

                        return result;
                    }).ToList());
                }
            }
        }
        private IEnumerable <RemoteSearchResult> GetResultsFromResponse(XmlDocument doc)
        {
            return(ReleaseResult.Parse(doc).Select(i =>
            {
                var result = new RemoteSearchResult
                {
                    Name = i.Title
                };

                if (!string.IsNullOrWhiteSpace(i.ReleaseId))
                {
                    result.SetProviderId(MetadataProviders.MusicBrainzAlbum, i.ReleaseId);
                }
                if (!string.IsNullOrWhiteSpace(i.ReleaseGroupId))
                {
                    result.SetProviderId(MetadataProviders.MusicBrainzAlbum, i.ReleaseGroupId);
                }

                return result;
            }));
        }
Example #14
0
        private async Task <ReleaseResult> GetReleaseResult(string albumName, string artistId, CancellationToken cancellationToken)
        {
            var url = string.Format(CultureInfo.InvariantCulture, "/ws/2/release/?query=\"{0}\" AND arid:{1}",
                                    WebUtility.UrlEncode(albumName),
                                    artistId);

            using var response = await GetMusicBrainzResponse(url, cancellationToken).ConfigureAwait(false);

            await using var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);

            using var oReader = new StreamReader(stream, Encoding.UTF8);
            var settings = new XmlReaderSettings
            {
                ValidationType  = ValidationType.None,
                CheckCharacters = false,
                IgnoreProcessingInstructions = true,
                IgnoreComments = true
            };

            using var reader = XmlReader.Create(oReader, settings);
            return(ReleaseResult.Parse(reader).FirstOrDefault());
        }
Example #15
0
        public override async Task <IResult <IRelease> > ReadAsync(ReleaseQueryArguments arguments)
        {
            // How to use this SonarQube rule right here?
            // https://rules.sonarsource.com/csharp/tag/async-await/RSPEC-4457

            if (arguments == null)
            {
                throw new ArgumentNullException(nameof(arguments));
            }

            // BUG: Be aware, pagination may apply to all request types (but not yet investigated)!
            // You may read here: https://developer.github.com/v3/#link-header

            using (HttpClient client = new HttpClient())
                using (HttpRequestMessage request = this.GetRequestMessage(HttpMethod.Get, arguments))
                    using (HttpResponseMessage response = await client.SendAsync(request))
                    {
                        if (response.IsSuccessStatusCode)
                        {
                            ReleaseResult result = new ReleaseResult();

                            base.ApplyCommonResults(response, arguments, result);

                            JsonSerializerSettings settings = new JsonSerializerSettings()
                            {
                                MissingMemberHandling = MissingMemberHandling.Ignore,
                            };
                            settings.Converters.Add(new AssetConverter());
                            settings.Converters.Add(new OwnerConverter());

                            result.Results = JsonConvert.DeserializeObject <IEnumerable <Release> >(await response.Content.ReadAsStringAsync(), settings);

                            return(result);
                        }

                        throw new AccessorRequestException(response);
                    }
        }
Example #16
0
            private static ReleaseResult ParseRelease(XmlReader reader)
            {
                var result = new ReleaseResult();

                reader.MoveToContent();
                reader.Read();

                // http://stackoverflow.com/questions/2299632/why-does-xmlreader-skip-every-other-element-if-there-is-no-whitespace-separator

                // Loop through each element
                while (!reader.EOF && reader.ReadState == ReadState.Interactive)
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                        case "id":
                        {
                            result.ReleaseId = reader.ReadElementContentAsString();
                            break;
                        }

                        case "song_title":
                        {
                            result.Title = reader.ReadElementContentAsString();
                            break;
                        }

                        case "year":
                        {
                            var val = reader.ReadElementContentAsString();
                            if (int.TryParse(val, out int year))
                            {
                                result.Year = year;
                            }
                            break;
                        }

                        case "artists":
                        {
                            using (var subReader = reader.ReadSubtree())
                            {
                                var artist = ParseArtistCredit(subReader);
                                if (artist != null)
                                {
                                    result.Artists.Add(new RemoteSearchResult
                                        {
                                            Name = artist
                                        });
                                }
                            }
                            break;
                        }

                        default:
                        {
                            reader.Skip();
                            break;
                        }
                        }
                    }
                    else
                    {
                        reader.Read();
                    }
                }

                return(result);
            }
        /// <summary>
        /// Creates the index file since we have the path to all images
        /// </summary>
        public void EndDocument(IDocument doc, object handle, ReleaseResult result)
        {
            /// The handle should always indicate whether or not the script created the document folder from scratch
            if (result != ReleaseResult.Succeeded && (bool)handle)
                Directory.Delete(m_DocFolder);

            index.CreateIndex(doc, m_FilenameReleaseData, Path.Combine(m_BatchFolder, m_IndexFileName));

            m_FilenameReleaseData.Clear();
        }
 /// <summary>
 /// This method will be called after everything has been sent to the script 
 /// and the batch has been closed by the application. The scripts usually perform 
 /// necessary cleanup based on current settings and the actual release conditions.
 /// </summary>
 public void EndRelease(object handle, ReleaseResult result)
 {
     /// Since we don't do anything special in this simple script,
     /// there's nothing to be cleaned up here. The handle should always be null.
 }
Example #19
0
            private static ReleaseResult ParseRelease(XmlReader reader, string releaseId)
            {
                var result = new ReleaseResult
                {
                    ReleaseId = releaseId
                };

                reader.MoveToContent();
                reader.Read();

                // http://stackoverflow.com/questions/2299632/why-does-xmlreader-skip-every-other-element-if-there-is-no-whitespace-separator

                // Loop through each element
                while (!reader.EOF && reader.ReadState == ReadState.Interactive)
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                        case "title":
                        {
                            result.Title = reader.ReadElementContentAsString();
                            break;
                        }

                        case "date":
                        {
                            var val = reader.ReadElementContentAsString();
                            if (DateTime.TryParse(val, out var date))
                            {
                                result.Year = date.Year;
                            }

                            break;
                        }

                        case "annotation":
                        {
                            result.Overview = reader.ReadElementContentAsString();
                            break;
                        }

                        case "release-group":
                        {
                            result.ReleaseGroupId = reader.GetAttribute("id");
                            reader.Skip();
                            break;
                        }

                        case "artist-credit":
                        {
                            using (var subReader = reader.ReadSubtree())
                            {
                                var artist = ParseArtistCredit(subReader);

                                if (!string.IsNullOrEmpty(artist.Item1))
                                {
                                    result.Artists.Add(artist);
                                }
                            }

                            break;
                        }

                        default:
                        {
                            reader.Skip();
                            break;
                        }
                        }
                    }
                    else
                    {
                        reader.Read();
                    }
                }

                return(result);
            }
 /// <summary>
 /// This method will be called after all documents have been sent to the script. 
 /// The scripts usually perform the necessary cleanup based on current settings 
 /// and the actual release conditions.
 /// </summary>
 public void EndBatch(IBatch batch, object handle, ReleaseResult result)
 {
     /// The handle should always indicate whether or not the script created the batch folder from scratch
     if (result != ReleaseResult.Succeeded && (bool)handle)
         Directory.Delete(m_BatchFolder);
 }
 /// <summary>
 /// For every document, this method will be called after all pages have been sent to the script. 
 /// The scripts usually perform the necessary cleanups based on current settings and the actual release conditions
 /// </summary>
 public void EndDocument(IDocument doc, object handle, ReleaseResult result)
 {
     /// The handle should always indicate whether the script created the document folder from scratch or not
     if (result != ReleaseResult.Succeeded && (bool)handle)
         Directory.Delete(m_DocFolder);
 }
Example #22
0
 public void EndIndex(object handle, ReleaseResult result, string outputFileName)
 {
 }
Example #23
0
 public void EndBatch(IBatch batch, object handle, ReleaseResult result)
 {
     _email.SendEmail(_fileList, _batchName);
 }
 public void EndBatch(IBatch batch, object handle, ReleaseResult result)
 {
 }
 public void EndRelease(object handle, ReleaseResult result)
 {
 }
Example #26
0
 public void EndRelease(object handle, ReleaseResult result)
 {
     _email = null;
 }
 /// <summary>
 /// This method will be called after everything has been sent to the script
 /// and the batch has been closed by the application. The scripts usually perform
 /// necessary cleanup based on current settings and the actual release conditions.
 /// </summary>
 public void EndRelease(object handle, ReleaseResult result)
 {
     /// Since we don't do anything special in this simple script,
     /// there's nothing to be cleaned up here. The handle should always be null.
 }
        public void EndBatch(IBatch batch, object handle, ReleaseResult result)
        {
            if (_settings.BatchCreation == 1) return;

            string pdfname = Path.Combine(_batchFolder, Path.ChangeExtension(_batchName, "pdf"));

            _docConverter.Convert(_documentList, pdfname, _settings.EnableChapters);
        }
 public void EndDocument(IDocument doc, object handle, ReleaseResult result)
 {
 }
 public void EndBatch(IBatch batch, object handle, ReleaseResult result)
 {
     _xmlData.CloseXml();
 }
 public void EndIndex(object handle, ReleaseResult result, string outputFileName)
 {
 }
        private ReleaseResult GetReleaseResult(XmlDocument doc)
        {
            var ns = new XmlNamespaceManager(doc.NameTable);
            ns.AddNamespace("mb", "http://musicbrainz.org/ns/mmd-2.0#");

            var result = new ReleaseResult
            {

            };

            var releaseIdNode = doc.SelectSingleNode("//mb:release-list/mb:release/@id", ns);

            if (releaseIdNode != null)
            {
                result.ReleaseId = releaseIdNode.Value;
            }

            var releaseGroupIdNode = doc.SelectSingleNode("//mb:release-list/mb:release/mb:release-group/@id", ns);

            if (releaseGroupIdNode != null)
            {
                result.ReleaseGroupId = releaseGroupIdNode.Value;
            }
            
            return result;
        }
Example #33
0
            private static ReleaseResult ParseRelease(XmlReader reader, string releaseId)
            {
                var result = new ReleaseResult
                {
                    ReleaseId = releaseId
                };

                reader.MoveToContent();
                reader.Read();

                // http://stackoverflow.com/questions/2299632/why-does-xmlreader-skip-every-other-element-if-there-is-no-whitespace-separator

                // Loop through each element
                while (!reader.EOF && reader.ReadState == ReadState.Interactive)
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                        case "title":
                        {
                            result.Title = reader.ReadElementContentAsString();
                            break;
                        }

                        case "date":
                        {
                            var      val = reader.ReadElementContentAsString();
                            DateTime date;
                            if (DateTime.TryParse(val, out date))
                            {
                                result.Year = date.Year;
                            }
                            break;
                        }

                        case "annotation":
                        {
                            result.Overview = reader.ReadElementContentAsString();
                            break;
                        }

                        case "release-group":
                        {
                            result.ReleaseGroupId = reader.GetAttribute("id");
                            reader.Skip();
                            break;
                        }

                        case "artist-credit":
                        {
                            // TODO

                            /*
                             * <artist-credit>
                             * <name-credit>
                             * <artist id="e225cda5-882d-4b80-b8a3-b36d7175b1ea">
                             * <name>SARCASTIC+ZOOKEEPER</name>
                             * <sort-name>SARCASTIC+ZOOKEEPER</sort-name>
                             * </artist>
                             * </name-credit>
                             * </artist-credit>
                             */
                            using (var subReader = reader.ReadSubtree())
                            {
                                var artist = ParseArtistCredit(subReader);

                                if (artist != null)
                                {
                                    result.Artists.Add(artist);
                                }
                            }

                            break;
                        }

                        default:
                        {
                            reader.Skip();
                            break;
                        }
                        }
                    }
                    else
                    {
                        reader.Read();
                    }
                }

                return(result);
            }