public override async Task <SeriesMessageResponse> PostSeries(SeriesFull request, ServerCallContext context)
        {
            try
            {
                var series   = _mapper.Map <SeriesFull, Series2>(request);
                var response = await _series.AddSeries(series);

                if (!response)
                {
                    throw new Exception("SeriesRep - PostSeries");
                }
                return(new SeriesMessageResponse()
                {
                    Signal = true, Poruka = "Uspesno sacuvano"
                });
            }
            catch (Exception e)
            {
                _logger.LogError(e, "ERROR");
                return(new SeriesMessageResponse()
                {
                    Signal = false, Poruka = "Greska"
                });
            }
        }
Example #2
0
 private void DownloadSeries(string seriesid)
 {
     seriesCache = tvdb.GetSeriesFullInformation(seriesid, FileType.ZIP);
     plvSeries.SelectedObject = seriesCache.Series;
     FillEpisodes(seriesCache.Episodes);
     FillActors(seriesCache.Actors);
     FillBanners(seriesCache.Banners);
     lastSeriesID = seriesCache.Series.ID;
 }
Example #3
0
        private static async Task SetSeriesData(TvDbWrapper api, string seriesPath, SeriesFull fullRec, IEnumerable <Banner> banners)
        {
            //get View.xml
            var viewFile = Path.Combine(seriesPath, Constants.SERIES_VIEW);
            await api.WriteSeriesViewXml(viewFile).ConfigureAwait(false);

            //fanart image
            var fanartImages = await api.GetArtworkPaths(fullRec.Series.Id, BannerType.fanart).ConfigureAwait(false);

            var fanart = Path.Combine(seriesPath, "fanart.jpg");

            if (fanartImages.Any())
            {
                var image = await api.GetImageByUrl(fanartImages.First()).ConfigureAwait(false);

                image = ImageHelper.ReduceImageSize(image);
                File.WriteAllBytes(fanart, image);
            }

            //folder image
            var folderImages = api.BannerImages(banners, BannerType.poster).ToArray();
            var poster       = Path.Combine(seriesPath, "folder.jpg");

            if (folderImages.Length > 0)
            {
                var image = await api.GetImageByUrl(folderImages[0]).ConfigureAwait(false);

                image = ImageHelper.ReduceImageSize(image);
                File.WriteAllBytes(poster, image);
            }

            //series xml
            var xmlPath = Path.Combine(seriesPath, Constants.SERIES_XML);
            var xml     = GetSeriesXml(fullRec.Series);

            File.WriteAllText(xmlPath, xml);
        }
Example #4
0
        public static async Task GetEpisodeMetadata(TvDbWrapper api, SeriesFull fullRec, string seasonPath, IEnumerable <Banner> banners, string seasonNo)
        {
            var thumbs       = GetExistingEpisodeThumbs(seasonPath);
            var bannerImages = api.BannerImages(banners, BannerType.season);

            var seasonEpisodes = fullRec.Episodes.Where(ep => ep.CombinedSeason == seasonNo);

            if (!seasonEpisodes.Any())
            {
                return;
            }

            var bytesSaved = 0;

            foreach (var key in thumbs.Keys)
            {
                //key sample : C:\BT\Series\Ray Donovan\Season 5\Ray Donovan.S05E06.Shelley Duvall.mkv
                var episodeNo = SeriesIOHelper.GetSeasonEpisodeFromName(key);
                //resolve episode from seasonEpisodes
                var episode         = seasonEpisodes.First(ep => ep.EpisodeNumber == episodeNo);
                var episodeFileName = episode.FileName;

                // thumbnails
                if (thumbs[key]?.Length == 0 && !string.IsNullOrEmpty(episodeFileName))
                {
                    //get banner TVDB filename
                    //get image using filename
                    var data = await api.GetImage(episodeFileName).ConfigureAwait(false);

                    if (data?.Length > 0)
                    {
                        var reduced = ImageHelper.ReduceImageSize(data);

                        if (reduced?.Length > 0)
                        {
                            bytesSaved += data.Length - reduced.Length;
                            //save image using episode name
                            var newExtension = Path.GetExtension(episodeFileName);
                            var imgFile      = Path.ChangeExtension(key, newExtension);
                            await File.WriteAllBytesAsync(imgFile, reduced).ConfigureAwait(false);
                        }
                    }
                }

                // xml content
                var xmlPath = Path.ChangeExtension(key, Constants.CONTENT_EXTENSION);
                if (!File.Exists(xmlPath))
                {
                    var xml = GetEpisodeXml(fullRec.Series, episode, bannerImages);
                    await File.WriteAllTextAsync(xmlPath, xml).ConfigureAwait(false);
                }
            }
            Debug.WriteLine($"Total bytes saved on episode images: {bytesSaved}");

            //get season thumb
            var seasonThumb = Path.Combine(seasonPath, Constants.SERIES_SEASON_THUMB);

            if (File.Exists(seasonThumb) && new FileInfo(seasonThumb).Length == 0) //if the save operation failed previously, the file would have been created without content
            {
                File.Delete(seasonThumb);
            }

            if (!File.Exists(seasonPath))
            {
                var epi          = seasonEpisodes.First();
                var seasonBanner = banners.ToList().Find(banner => banner.BannerType == "season" && banner.Season == epi.CombinedSeason);
                if (seasonBanner is not null)
                {
                    var img = await api.GetImage(seasonBanner.BannerPath).ConfigureAwait(false) ?? await api.GetImage(seasonBanner.ThumbnailPath).ConfigureAwait(false);

                    if (img is not null)
                    {
                        var reduced = ImageHelper.ReduceImageSize(img);
                        await File.WriteAllBytesAsync(seasonThumb, reduced).ConfigureAwait(false);
                    }
                }
            }

            //get View.xml
            var viewFile = Path.Combine(seasonPath, Constants.SEASON_VIEW);

            if (!File.Exists(viewFile))
            {
                await api.WriteSeasonViewXml(viewFile).ConfigureAwait(false);
            }
        }