public void TestAddSeries()
        {
            AddSeries       req;
            Request         req2;
            RecombeeBinding resp;

            // it 'does not fail with valid entity id'
            req  = new AddSeries("valid_id");
            resp = client.Send(req);
            // it 'fails with invalid entity id'
            req = new AddSeries("$$$not_valid$$$");
            try
            {
                client.Send(req);
                Assert.True(false, "No exception thrown");
            }
            catch (ResponseException ex)
            {
                Assert.Equal(400, (int)ex.StatusCode);
            }
            // it 'really stores entity to the system'
            req  = new AddSeries("valid_id2");
            resp = client.Send(req);
            try
            {
                client.Send(req);
                Assert.True(false, "No exception thrown");
            }
            catch (ResponseException ex)
            {
                Assert.Equal(409, (int)ex.StatusCode);
            }
        }
Example #2
0
        private void HandleAddSeries(AddSeries series)
        {
            _seriesIndex.Add(series.Series.Name, series.Series);
            _chart.Series.Add(series.Series);

            SetYBoundary();
        }
 private void HandleAddSeries(AddSeries series)
 {
     if (!string.IsNullOrEmpty(series.Series.Name) && !_seriesIndex.ContainsKey(series.Series.Name))
     {
         _seriesIndex.Add(series.Series.Name, series.Series);
         _chart.Series.Add(series.Series);
     }
 }
 private void HandleAddSeries(AddSeries series)
 {
     if (!string.IsNullOrEmpty(series.Series.Name) && !_seriesIndex.ContainsKey(series.Series.Name))
     {
         _seriesIndex.Add(series.Series.Name, series.Series);
         _chart.Series.Add(series.Series);
     }
 }
 private void HandleAddSeries(AddSeries series)
 {
     if (!string.IsNullOrEmpty(series.Series.Name) && !this.seriesIndex.ContainsKey(series.Series.Name))
     {
         this.seriesIndex.Add(series.Series.Name, series.Series);
         this.chart.Series.Add(series.Series);
         this.SetChartBoundaries();
     }
 }
Example #6
0
 private void HandleAddSeries(AddSeries addSeries)
 {
     if (!string.IsNullOrEmpty(addSeries.Series.Name) && !_seriesIndex.ContainsKey(addSeries.Series.Name))
     {
         _seriesIndex.Add(addSeries.Series.Name, addSeries.Series);
         _chart.Series.Add(addSeries.Series);
         SetChartBoundaries();
     }
 }
        private void HandleAddSeries(AddSeries series)
        {
            if (!string.IsNullOrEmpty(series.Series.Name) && !seriesIndex.ContainsKey(series.Series.Name))
            {
                seriesIndex.Add(series.Series.Name, series.Series);
                chart.Series.Add(series.Series);

                SetChartBoundaries();
            }
        }
Example #8
0
 void handleAddSeries(AddSeries series)
 {
     if (string.IsNullOrEmpty(series.Series.Name) || _seriesIndex.ContainsKey(series.Series.Name))
     {
         return;
     }
     _seriesIndex.Add(series.Series.Name, series.Series);
     _chart.Series.Add(series.Series);
     setChartBoundaries();
 }
Example #9
0
 private void btnAddSeries_Click(object sender, EventArgs e)
 {
     try
     {
         adSe = new AddSeries(BrandID);
         adSe.ShowDialog();
     }
     catch (Exception ex)
     {
     }
     setCombobox();
 }
Example #10
0
        void AddSeriesClick(object sender, System.EventArgs e)
        {
            var a = new AddSeries();

            if (a.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                Series s = new Series();
                s.Name            = a.SeriesName;
                s.Table.TableName = a.TableName;
                s.Units           = a.Units;
                s.TimeInterval    = a.TimeInterval;
                DB.AddSeries(s, CurrentFolder);
            }
        }
Example #11
0
        public async Task <IActionResult> Add(AddSeries addSeries)
        {
            if (ModelState.IsValid)
            {
                var series = new Series
                {
                    Name         = addSeries.Name,
                    Author       = addSeries.Author,
                    Artist       = addSeries.Artist,
                    Synopsis     = addSeries.Synopsis,
                    Type         = addSeries.Type,
                    Status       = addSeries.Status,
                    UrlSlug      = Utils.GenerateSlug(addSeries.Name),
                    MangadexInfo = new MangadexSeries
                    {
                        MangadexId  = addSeries.MangadexId ?? 0,
                        DisplayLink = addSeries.DisplayMangadexLink
                    }
                };

                await _naniWebContext.Series.AddAsync(series);

                await _naniWebContext.SaveChangesAsync();

                var path = $"{_webHostEnvironment.WebRootPath}{Path.DirectorySeparatorChar}images{Path.DirectorySeparatorChar}covers{Path.DirectorySeparatorChar}{series.Id}.png";
                Directory.CreateDirectory(path.Replace($"{Path.DirectorySeparatorChar}{series.Id}.png", string.Empty));

                using (var file = System.IO.File.Create(path))
                {
                    await addSeries.Cover.CopyToAsync(file);
                }

                var fileInfo    = new FileInfo(path);
                var destination = fileInfo.Directory;

                Utils.ResizeImage(fileInfo, destination, $"{series.Id}_small", 209, 300);
                Utils.ResizeImage(fileInfo, destination, $"{series.Id}_smaller", 209 / 2, 300 / 2);

                return(RedirectToAction("List"));
            }

            TempData["Error"] = true;

            return(RedirectToAction("Add"));
        }
Example #12
0
        public bool CreateSeries(ShowList showList, List <GetSeries> getSeries)
        {
            Status status = new Status();

            try
            {
                if (!getSeries.Where(x => x.tvdbId == showList.show.ids.tvdb).Any())
                {
                    AddSeries series = new AddSeries
                    {
                        monitored      = true,
                        tvdbId         = showList.show.ids.tvdb,
                        title          = showList.show.title,
                        titleSlug      = showList.show.ids.slug,
                        seasonFolder   = true,
                        profileId      = Settings._settings.SonarrProfileId,
                        rootFolderPath = $"{Settings._settings.SonarrRootFolderPath}/{showList.show.title}"
                    };

                    AddOptions addOptions = new AddOptions {
                        ignoreEpisodesWithFiles = false, searchForMissingEpisodes = true
                    };
                    series.addOptions = addOptions;

                    status = PushSeries(series);

                    if (status.Success)
                    {
                        Console.WriteLine($"Added {series.title}");
                    }
                    else
                    {
                        Console.WriteLine($"Failed to add {series.title}, {status.ErrorMessage}");
                        return(false);
                    }
                }

                return(true);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to add {showList.show.title}, {ex.Message}");
                return(false);
            }
        }
Example #13
0
        public Status PushSeries(AddSeries series)
        {
            HttpClient         http    = new HttpClient();
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, Settings._settings.SonarrApiSeries);

            request.Headers.Add("X-Api-Key", Settings._settings.SonarrApiKey);

            string json = JsonConvert.SerializeObject(series);

            request.Content = new StringContent(json, Encoding.UTF8, "application/json");

            Status status = new Status();
            HttpResponseMessage responseMessage = http.SendAsync(request).GetAwaiter().GetResult();

            status.SeriesName = series.title;
            status.Success    = responseMessage.StatusCode == HttpStatusCode.Created;

            if (!status.Success)
            {
                status.ErrorMessage = responseMessage.Content.ReadAsStringAsync().Result;
            }

            return(status);
        }
Example #14
0
        public static async Task AddSeries(HttpContext httpContext, AddSeries addSeries)
        {
            if (!httpContext.Session.GetAccountId(out long accountId))
            {
                throw new HttpException(500, "Failed to get AccountId");
            }

            await using var context = new DatabaseContext();
            var account = await(from a in context.Accounts where a.Id.Equals(accountId) select a).FirstOrDefaultAsync();

            if (account == null)
            {
                throw new HttpException(500, "Account does not exist");
            }

            if (account.AccountType != AccountType.Admin)
            {
                throw new HttpException(403, "Access denied");
            }

            var hasAnyTitle = await(from t in context.Titles where t.IMDbId.Equals(addSeries.ImdbId) select t).AnyAsync();

            if (hasAnyTitle)
            {
                throw new HttpException(500, "There is already a title with that id.");
            }

            var client  = new RestClient($"https://imdb8.p.rapidapi.com/title/get-overview-details?currentCountry=US&tconst={addSeries.ImdbId}");
            var request = new RestRequest(Method.GET);

            request.AddHeader("x-rapidapi-host", "imdb8.p.rapidapi.com");
            request.AddHeader("x-rapidapi-key", HtcPlugin.Config.RapidApi.Key);
            var response = await client.ExecuteAsync(request);

            var titleOverview = JsonSerializer.Deserialize <TitleOverviewDetails>(response.Content);

            client  = new RestClient($"https://imdb8.p.rapidapi.com/title/get-seasons?tconst={addSeries.ImdbId}");
            request = new RestRequest(Method.GET);
            request.AddHeader("x-rapidapi-host", "imdb8.p.rapidapi.com");
            request.AddHeader("x-rapidapi-key", HtcPlugin.Config.RapidApi.Key);
            response = await client.ExecuteAsync(request);

            SeasonDetails[] seasonsDetails = JsonSerializer.Deserialize <SeasonDetails[]>(response.Content);

            string outline = titleOverview.PlotOutline?.Text;
            string summary = titleOverview.PlotSummary?.Text;

            string classification = null;

            try {
                classification = titleOverview.Certificates.Us[0].Certificate;
            } catch {
                // ignored
            }

            var title = new Title {
                Id             = Security.IdGen.GetId(),
                Type           = TitleType.Series,
                OriginalName   = titleOverview.Title.Title,
                Length         = titleOverview.Title.RunningTimeInMinutes,
                IMDbId         = addSeries.ImdbId,
                Seasons        = 0,
                Episodes       = titleOverview.Title.NumberOfEpisodes,
                Year           = titleOverview.Title.Year,
                Poster         = titleOverview.Title.Image.Url,
                Genres         = JsonSerializer.Serialize(titleOverview.Genres, typeof(string[])),
                Classification = classification,
                Summary        = summary,
                Outline        = outline,
                Likes          = 0,
                Dislikes       = 0,
            };
            await context.Titles.AddAsync(title);

            var episodes = 0;
            var seasons  = 0;

            foreach (var season in seasonsDetails)
            {
                var seasonModel = new Season {
                    Id      = Security.IdGen.GetId(),
                    Name    = null,
                    Number  = season.Season,
                    TitleId = title.Id,
                };
                await context.Seasons.AddAsync(seasonModel);

                seasons++;
                foreach (var episode in season.Episodes)
                {
                    var episodeModel = new Episode {
                        Id           = Security.IdGen.GetId(),
                        OriginalName = episode.Title,
                        Number       = episode.Episode,
                        Year         = episode.Year,
                        IMDbId       = episode.Id,
                        SeasonId     = seasonModel.Id,
                        TitleId      = title.Id,
                    };
                    await context.Episodes.AddAsync(episodeModel);

                    episodes++;
                }
            }

            await context.SaveChangesAsync();

            title.Episodes = episodes;
            title.Seasons  = seasons;
            context.Titles.Update(title);

            await context.SaveChangesAsync();

            await HtcPlugin.ElasticClient.IndexAsync(new ElasticTitle(title), idx => idx.Index("title"));

            await httpContext.Response.WriteAsync($"{{\"success\":true,\"data\":{response.Content}}}");
        }
Example #15
0
        private void HandleAddSeries(AddSeries series)
        {
            if (string.IsNullOrEmpty(series.Series.Name) || _seriesIndex.ContainsKey(series.Series.Name))
            {
                return;
            }

            _seriesIndex.Add(series.Series.Name, series.Series);
            _chart.Series.Add(series.Series);

            SetChartBoundaries();
        }
Example #16
0
 private void HandleAddSeries(AddSeries addSeries)
 {
     if (!String.IsNullOrWhiteSpace(addSeries.Series.Name)
             && !_seriesIndex.ContainsKey(addSeries.Series.Name))
     {
         _seriesIndex.Add(addSeries.Series.Name, addSeries.Series);
         _chart.Series.Add(addSeries.Series);
         SetChartBoundaries();
     }
 }