node-csfd-api-racintom 1.6.0 → 1.8.0

package/src/interfaces/search.interface.ts

@@ -0,0 +1,32 @@
+import { CSFDScreening } from './global';
+import { CSFDCreator } from './movie.interface';
+
+export interface CSFDSearch {
+  movies: CSFDSearchMovie[];
+  tvSeries: CSFDSearchMovie[];
+  creators: CSFDSearchCreator[];
+  users: CSFDSearchUser[];
+}
+
+export interface CSFDSearchMovie extends CSFDScreening {
+  poster: string;
+  origins: string[];
+  creators: CSFDSearchCreators;
+}
+
+export interface CSFDSearchUser {
+  id: number;
+  user: string;
+  userRealName: string;
+  avatar: string;
+  url: string;
+}
+
+export interface CSFDSearchCreator extends CSFDCreator {
+  image: string;
+}
+
+export interface CSFDSearchCreators {
+  directors: CSFDCreator[];
+  actors: CSFDCreator[];
+}

package/src/interfaces/season.interface.ts

@@ -0,0 +1,12 @@
+export type CSFDSeason = {
+  description: string | undefined;
+  thumbnail: string;
+  episodeList: CSFDEpisodeInfo[]
+  origin: string;
+}
+
+export type CSFDEpisodeInfo = {
+  name: string
+  seasonEpisodeIdentifier: string;
+  linkToDetail: string
+}

package/src/interfaces/user-ratings.interface.ts

@@ -0,0 +1,21 @@
+import { CSFDFilmTypes, CSFDScreening, CSFDStars } from './global';
+
+export interface CSFDUserRatings extends CSFDScreening {
+  userRating: CSFDStars;
+  userDate: string; // TODO datetime
+}
+
+export interface CSFDUserRatingConfig {
+  includesOnly?: CSFDFilmTypes[];
+  excludes?: CSFDFilmTypes[];
+  /**
+   * Fetch all ratings. (Warning: Use it wisely. Can be detected and banned. Consider using it together with `allPagesDelay` attribute)
+   */
+  allPages?: boolean;
+  /**
+   * Delay on each page request. In milliseconds
+   */
+  allPagesDelay?: number;
+}
+
+export type Colors = 'lightgrey' | 'blue' | 'red' | 'grey';

package/src/services/creator.service.ts

@@ -0,0 +1,34 @@
+import { HTMLElement, parse } from 'node-html-parser';
+import { fetchPage } from '../fetchers';
+import { getBio, getBirthdayInfo, getFilms, getName, getPhoto } from '../helpers/creator.helper';
+import { CSFDCreator } from '../interfaces/creator.interface';
+import { creatorUrl } from '../vars';
+
+export class CreatorScraper {
+  private person: CSFDCreator;
+
+  public async creator(creatorId: number): Promise<CSFDCreator> {
+    const url = creatorUrl(+creatorId);
+    const response = await fetchPage(url);
+
+    const creatorHtml = parse(response);
+
+    const asideNode = creatorHtml.querySelector('.creator-about');
+    const filmsNode = creatorHtml.querySelector('.creator-filmography');
+    this.buildCreator(+creatorId, asideNode, filmsNode);
+    return this.person;
+  }
+
+  private buildCreator(id: number, asideEl: HTMLElement, filmsNode: HTMLElement) {
+    this.person = {
+      id,
+      name: getName(asideEl),
+      birthday: getBirthdayInfo(asideEl)?.birthday,
+      birthplace: getBirthdayInfo(asideEl)?.birthPlace,
+      photo: getPhoto(asideEl),
+      age: getBirthdayInfo(asideEl)?.age || null,
+      bio: getBio(asideEl),
+      films: getFilms(filmsNode)
+    };
+  }
+}

package/src/services/movie.service.ts

@@ -0,0 +1,89 @@
+import { HTMLElement, parse } from 'node-html-parser';
+import { fetchPage } from '../fetchers';
+import {
+  getBoxMovies,
+  getColorRating,
+  getDescriptions,
+  getDuration,
+  getGenres,
+  getGroup,
+  getOrigins,
+  getPoster,
+  getPremieres,
+  getRandomPhoto,
+  getRating,
+  getRatingCount, getSeasonsInfo,
+  getTags,
+  getTitle,
+  getTitlesOther,
+  getTrivia,
+  getType,
+  getVods,
+  getYear
+} from '../helpers/movie.helper';
+import { CSFDFilmTypes } from '../interfaces/global';
+import { CSFDMovie } from '../interfaces/movie.interface';
+import { movieUrl } from '../vars';
+
+export class MovieScraper {
+  private film: CSFDMovie;
+
+  public async movie(movieId: number): Promise<CSFDMovie> {
+    const url = movieUrl(+movieId);
+    const response = await fetchPage(url);
+
+    const movieHtml = parse(response);
+
+    const pageClasses = movieHtml.querySelector('.page-content').classNames.split(' ');
+    const asideNode = movieHtml.querySelector('.aside-movie-profile');
+    const movieNode = movieHtml.querySelector('.main-movie-profile');
+    const jsonLd = movieHtml.querySelector('script[type="application/ld+json"]').innerText;
+    this.buildMovie(+movieId, movieNode, asideNode, pageClasses, jsonLd);
+    return this.film;
+  }
+
+  private buildMovie(
+    movieId: number,
+    el: HTMLElement,
+    asideEl: HTMLElement,
+    pageClasses: string[],
+    jsonLd: string
+  ) {
+    this.film = {
+      id: movieId,
+      title: getTitle(el),
+      year: getYear(jsonLd),
+      duration: getDuration(jsonLd, el),
+      descriptions: getDescriptions(el),
+      genres: getGenres(el),
+      type: getType(el) as CSFDFilmTypes,
+      url: movieUrl(movieId),
+      origins: getOrigins(el),
+      colorRating: getColorRating(pageClasses),
+      rating: getRating(asideEl),
+      ratingCount: getRatingCount(asideEl),
+      titlesOther: getTitlesOther(el),
+      poster: getPoster(el),
+      photo: getRandomPhoto(el),
+      trivia: getTrivia(el),
+      creators: {
+        directors: getGroup(el, 'Režie'),
+        writers: getGroup(el, 'Scénář'),
+        cinematography: getGroup(el, 'Kamera'),
+        music: getGroup(el, 'Hudba'),
+        actors: getGroup(el, 'Hrají'),
+        basedOn: getGroup(el, 'Předloha'),
+        producers: getGroup(el, 'Produkce'),
+        filmEditing: getGroup(el, 'Střih'),
+        costumeDesign: getGroup(el, 'Kostýmy'),
+        productionDesign: getGroup(el, 'Scénografie')
+      },
+      vod: getVods(asideEl),
+      tags: getTags(asideEl),
+      premieres: getPremieres(asideEl),
+      related: getBoxMovies(asideEl, 'Související'),
+      similar: getBoxMovies(asideEl, 'Podobné'),
+      seasons: getSeasonsInfo(el)
+    };
+  }
+}

package/src/services/search.service.ts

@@ -0,0 +1,101 @@
+import { HTMLElement, parse } from 'node-html-parser';
+import { fetchPage } from '../fetchers';
+import { parseIdFromUrl } from '../helpers/global.helper';
+import { getAvatar, getUser, getUserRealName, getUserUrl } from '../helpers/search-user.helper';
+import {
+  getColorRating,
+  getOrigins,
+  getPoster,
+  getTitle,
+  getType,
+  getUrl,
+  getYear,
+  parsePeople
+} from '../helpers/search.helper';
+import { CSFDSearch, CSFDSearchMovie, CSFDSearchUser } from '../interfaces/search.interface';
+import { searchUrl } from '../vars';
+
+export class SearchScraper {
+  public async search(text: string): Promise<CSFDSearch> {
+    const url = searchUrl(text);
+    const response = await fetchPage(url);
+
+    const html = parse(response);
+    const moviesNode = html.querySelectorAll('.main-movies article');
+    const usersNode = html.querySelectorAll('.main-users article');
+    const tvSeriesNode = html.querySelectorAll('.main-series article');
+
+    return this.parseSearch(moviesNode, usersNode, tvSeriesNode);
+  }
+
+  private parseSearch(
+    moviesNode: HTMLElement[],
+    usersNode: HTMLElement[],
+    tvSeriesNode: HTMLElement[]
+  ) {
+    const movies: CSFDSearchMovie[] = [];
+    const users: CSFDSearchUser[] = [];
+    const tvSeries: CSFDSearchMovie[] = [];
+
+    moviesNode.map((m) => {
+      const url = getUrl(m);
+
+      const movie: CSFDSearchMovie = {
+        id: parseIdFromUrl(url),
+        title: getTitle(m),
+        year: getYear(m),
+        url: `https://www.csfd.cz${url}`,
+        type: getType(m),
+        colorRating: getColorRating(m),
+        poster: getPoster(m),
+        origins: getOrigins(m),
+        creators: {
+          directors: parsePeople(m, 'directors'),
+          actors: parsePeople(m, 'actors')
+        }
+      };
+      movies.push(movie);
+    });
+
+    usersNode.map((m) => {
+      const url = getUserUrl(m);
+
+      const user: CSFDSearchUser = {
+        id: parseIdFromUrl(url),
+        user: getUser(m),
+        userRealName: getUserRealName(m),
+        avatar: getAvatar(m),
+        url: `https://www.csfd.cz${url}`
+      };
+      users.push(user);
+    });
+
+    tvSeriesNode.map((m) => {
+      const url = getUrl(m);
+
+      const user: CSFDSearchMovie = {
+        id: parseIdFromUrl(url),
+        title: getTitle(m),
+        year: getYear(m),
+        url: `https://www.csfd.cz${url}`,
+        type: getType(m),
+        colorRating: getColorRating(m),
+        poster: getPoster(m),
+        origins: getOrigins(m),
+        creators: {
+          directors: parsePeople(m, 'directors'),
+          actors: parsePeople(m, 'actors')
+        }
+      };
+      tvSeries.push(user);
+    });
+
+    const search: CSFDSearch = {
+      movies: movies,
+      users: users,
+      tvSeries: tvSeries,
+      creators: []
+    };
+    return search;
+  }
+}

package/src/services/season.service.ts

@@ -0,0 +1,55 @@
+import { fetchPage } from '../fetchers';
+import { HTMLElement, parse } from 'node-html-parser';
+import { seasonUrl } from '../vars';
+import { CSFDEpisodeInfo, CSFDSeason } from '../interfaces/season.interface';
+
+export class SeasonScraper {
+  public async season(url: string): Promise<CSFDSeason> {
+    const response = await fetchPage(seasonUrl(url));
+
+    const seasonHtml = parse(response);
+
+    const movieNode = seasonHtml.querySelector('.main-movie-profile');
+
+    return this.buildSeason(movieNode);
+  }
+
+  private buildSeason(
+    movieNode: HTMLElement
+  ): CSFDSeason {
+    return {
+      origin: this.getOriginFromHtml(movieNode),
+      description: this.getDescriptionFromHtml(movieNode),
+      thumbnail: this.getThumbnailFromHtml(movieNode),
+      episodeList: this.getEpisodeListFromHtml(movieNode),
+    }
+  }
+
+  private getOriginFromHtml(movieNode: HTMLElement): string {
+    return movieNode.querySelector('.film-info-content .origin').textContent;
+  }
+
+  private getDescriptionFromHtml(movieNode: HTMLElement): string | undefined {
+    return movieNode.querySelector('.plot-full')?.textContent;
+  }
+
+  private getThumbnailFromHtml(movieNode: HTMLElement): string {
+    return movieNode.querySelector('.film-posters img').getAttribute('src');
+  }
+
+  private getEpisodeListFromHtml(movieNode: HTMLElement): CSFDEpisodeInfo[] {
+    return movieNode.querySelectorAll('.film-episodes-list li').map(container => {
+      const nameContainer = container.querySelector('.film-title-name')
+
+      return {
+        name: nameContainer.textContent,
+        seasonEpisodeIdentifier: container.querySelector('.film-title-info').textContent,
+        linkToDetail: nameContainer.getAttribute('href'),
+      }
+    })
+  }
+
+
+
+}
+

package/src/services/user-ratings.service.ts

@@ -0,0 +1,106 @@
+import { HTMLElement, parse } from 'node-html-parser';
+import { fetchPage } from '../fetchers';
+import {
+  getColorRating,
+  getDate,
+  getId,
+  getTitle,
+  getType,
+  getUrl,
+  getUserRating,
+  getYear,
+  sleep
+} from '../helpers/user-ratings.helper';
+import { CSFDColorRating, CSFDStars } from '../interfaces/global';
+import { CSFDUserRatingConfig, CSFDUserRatings } from '../interfaces/user-ratings.interface';
+import { userRatingsUrl } from '../vars';
+
+export class UserRatingsScraper {
+  private films: CSFDUserRatings[] = [];
+
+  public async userRatings(
+    user: string | number,
+    config?: CSFDUserRatingConfig
+  ): Promise<CSFDUserRatings[]> {
+    let allMovies: CSFDUserRatings[] = [];
+    const url = userRatingsUrl(user);
+    const response = await fetchPage(url);
+
+    const items = parse(response);
+    const movies = items.querySelectorAll('.box-user-rating .table-container tbody tr');
+
+    // Get number of pages
+    const pagesNode = items.querySelector('.pagination');
+    const pages = +pagesNode?.childNodes[pagesNode.childNodes.length - 4].rawText || 1;
+
+    allMovies = this.getPage(config, movies);
+
+    if (config?.allPages) {
+      console.log('User', user, url);
+      console.log('Fetching all pages', pages);
+      for (let i = 2; i <= pages; i++) {
+        console.log('Fetching page', i, 'out of', pages, '...');
+        const url = userRatingsUrl(user, i);
+        const response = await fetchPage(url);
+
+        const items = parse(response);
+        const movies = items.querySelectorAll('.box-user-rating .table-container tbody tr');
+        allMovies = [...this.getPage(config, movies)];
+
+        // Sleep
+        if (config.allPagesDelay) {
+          await sleep(config.allPagesDelay);
+        }
+      }
+      return allMovies;
+    }
+
+    return allMovies;
+  }
+
+  private getPage(config: CSFDUserRatingConfig, movies: HTMLElement[]) {
+    if (config) {
+      if (config.includesOnly?.length && config.excludes?.length) {
+        console.warn(
+          `node-csfd-api:
+        You can not use both parameters 'includesOnly' and 'excludes'.
+        Parameter 'includesOnly' will be used now:`,
+          config.includesOnly
+        );
+      }
+    }
+
+    for (const el of movies) {
+      const type = getType(el);
+
+      // Filtering includesOnly
+      if (config?.includesOnly?.length) {
+        if (config.includesOnly.some((include) => type === include)) {
+          this.buildUserRatings(el);
+        }
+        // Filter exludes
+      } else if (config?.excludes?.length) {
+        if (!config.excludes.some((exclude) => type === exclude)) {
+          this.buildUserRatings(el);
+        }
+      } else {
+        // Without filtering
+        this.buildUserRatings(el);
+      }
+    }
+    return this.films;
+  }
+
+  private buildUserRatings(el: HTMLElement) {
+    this.films.push({
+      id: getId(el),
+      title: getTitle(el),
+      year: getYear(el),
+      type: getType(el),
+      url: getUrl(el),
+      colorRating: getColorRating(el) as CSFDColorRating,
+      userDate: getDate(el),
+      userRating: getUserRating(el) as CSFDStars
+    });
+  }
+}

package/src/vars.ts

@@ -0,0 +1,16 @@
+export const userRatingsUrl = (user: string | number, page?: number): string =>
+  `https://www.csfd.cz/uzivatel/${encodeURIComponent(user)}/hodnoceni/${
+    page ? '?page=' + page : ''
+  }`;
+
+export const movieUrl = (movie: number): string =>
+  `https://www.csfd.cz/film/${encodeURIComponent(movie)}/prehled/`;
+
+export const creatorUrl = (creator: number | string): string =>
+  `https://www.csfd.cz/tvurce/${encodeURIComponent(creator)}`;
+
+export const searchUrl = (text: string): string =>
+  `https://www.csfd.cz/hledat/?q=${encodeURIComponent(text)}`;
+
+export const seasonUrl = (url: string): string =>
+  `https://www.csfd.cz/${url}`;

package/tests/creator.test.ts

@@ -0,0 +1,182 @@
+import { parse } from 'node-html-parser';
+import { describe, expect, test } from 'vitest';
+import {
+  getBio,
+  getBirthdayInfo,
+  getFilms,
+  getName,
+  getPhoto
+} from '../src/helpers/creator.helper';
+import { CSFDCreatorScreening } from '../src/interfaces/creator.interface';
+import { actorMock } from './mocks/creator-actor.html';
+import { composerMock } from './mocks/creator-composer-empty.html';
+import { directorMock } from './mocks/creator-director.html';
+
+const html = parse(directorMock);
+const asideNode = html.querySelector('.creator-about');
+const filmsNode = html.querySelector('.creator-filmography');
+
+const htmlActor = parse(actorMock);
+const asideNodeActor = htmlActor.querySelector('.creator-about');
+const filmsNodeActor = htmlActor.querySelector('.creator-filmography');
+
+const htmlComposer = parse(composerMock);
+const asideNodeComposer = htmlComposer.querySelector('.creator-about');
+const filmsNodeComposer = htmlComposer.querySelector('.creator-filmography');
+
+describe('Creator info', () => {
+  test('Name', () => {
+    const creator = getName(asideNode);
+    expect(creator).toEqual<string>('Quentin Tarantino');
+  });
+
+  test('Bio', () => {
+    const creator = getBio(asideNode);
+    expect(creator).toEqual<string>(
+      'Narodil se teprve šestnáctileté Connii McHugh, která mu dala křestní jméno podle své oblíbené postavy Quinta ze seriálu Gunsmoke. Jeho biologickým otcem byl jistý Tony Tarantino, který rodinu opustil když byl Quentin ještě malinký a nikdy o syna nejevil zájem (přesněji řečeno jen do doby, než se potomek stal slavným – pak se na jeho úspěchu pokoušel parazitovat). Jeho náhradním tatínkem se stal hudebník s československými kořeny, který si Connii vzal a Quentina…'
+    );
+  });
+
+  test('Photo', () => {
+    const creator = getPhoto(asideNode);
+    expect(creator).toEqual<string>(
+      'https://image.pmgstatic.com/cache/resized/w100h132crop/files/images/creator/photos/164/515/164515525_b98f8a.jpg'
+    );
+  });
+});
+
+describe('Creator birthday info', () => {
+  test('Birthday', () => {
+    const creator = getBirthdayInfo(asideNode)?.birthday;
+    expect(creator).toEqual<string>('27.03.1963');
+  });
+
+  test('Birthplace', () => {
+    const creator = getBirthdayInfo(asideNode)?.birthPlace;
+    expect(creator).toEqual<string>('Knoxville, Tennessee, USA');
+  });
+
+  test('Age', () => {
+    const creator = getBirthdayInfo(asideNode)?.age;
+    expect(creator).toEqual<number>(61);
+  });
+});
+
+describe("Creator's films", () => {
+  test('First film from first section', () => {
+    const films = getFilms(filmsNode) as CSFDCreatorScreening[];
+    expect(films[0].title).toEqual<string>('The Movie Critic');
+  });
+
+  test('Last film from first section', () => {
+    const films = getFilms(filmsNode) as CSFDCreatorScreening[];
+    expect(films[films.length - 1].id).toEqual<number>(1051715);
+  });
+
+  test('Year second movie', () => {
+    const films = getFilms(filmsNode) as CSFDCreatorScreening[];
+    expect(films[1].year).toEqual<number>(2019);
+  });
+});
+
+// actor
+
+describe('Actor info', () => {
+  test('Name', () => {
+    const creator = getName(asideNodeActor);
+    expect(creator).toEqual<string>('Mads Mikkelsen');
+  });
+
+  test('Bio', () => {
+    const creator = getBio(asideNodeActor);
+    expect(creator).toEqual<string>(
+      'Dánský herec, celým jménem Mads Dittmann Mikkelsen, se narodil v roce 1965 v kodaňské čtvrti Østerbro. Dříve než se vrhl na hereckou dráhu, pracoval 8 let jako profesionální tanečník. Herecké vzdělání získal Mikkelsen na herecké škole při divadle v Århusu. Školu zakončil v roce 1996. Co se týká soukromého života je Mads Mikkelsen, který za svůj nejoblíbenější film považuje Taxikáře od Martina Scorseseho, od roku 1987 ženatý s dánskou choreografkou Hanne Jacobsen.…'
+    );
+  });
+
+  test('Photo', () => {
+    const creator = getPhoto(asideNodeActor);
+    expect(creator).toEqual<string>(
+      'https://image.pmgstatic.com/cache/resized/w100h132crop/files/images/creator/photos/166/233/166233274_298dbd.jpg'
+    );
+  });
+});
+
+describe('Actor birthday info', () => {
+  test('Birthday', () => {
+    const creator = getBirthdayInfo(asideNodeActor)?.birthday;
+    expect(creator).toEqual<string>('22.11.1965');
+  });
+
+  test('Birthplace', () => {
+    const creator = getBirthdayInfo(asideNodeActor)?.birthPlace;
+    expect(creator).toEqual<string>('Østerbro, København, Dánsko');
+  });
+
+  test('Age', () => {
+    const creator = getBirthdayInfo(asideNodeActor)?.age;
+    expect(creator).toEqual<number>(58);
+  });
+});
+
+describe("Creator's films", () => {
+  test('First film from first section', () => {
+    const films = getFilms(filmsNodeActor) as CSFDCreatorScreening[];
+    expect(films[0].title).toEqual<string>('The Billion Dollar Spy');
+  });
+
+  test('Last film from first section', () => {
+    const films = getFilms(filmsNodeActor) as CSFDCreatorScreening[];
+    expect(films[films.length - 1].id).toEqual<number>(88874);
+  });
+
+  test('Year second movie', () => {
+    const films = getFilms(filmsNodeActor) as CSFDCreatorScreening[];
+    expect(films[1].year).toEqual<number>(2025);
+  });
+});
+
+// composer
+
+describe('Composer info', () => {
+  test('Name', () => {
+    const creator = getName(asideNodeComposer);
+    expect(creator).toEqual<string>('Sven Mikkelsen');
+  });
+
+  test('Bio', () => {
+    const creator = getBio(asideNodeComposer);
+    expect(creator).toEqual<string>(null);
+  });
+
+  test('Photo', () => {
+    const creator = getPhoto(asideNodeComposer);
+    expect(creator).toEqual<string>(
+      'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7'
+    );
+  });
+});
+
+describe('Composer birthday info', () => {
+  test('Birthday', () => {
+    const creator = getBirthdayInfo(asideNodeComposer)?.birthday;
+    expect(creator).toEqual<string>('');
+  });
+
+  test('Birthplace', () => {
+    const creator = getBirthdayInfo(asideNodeComposer)?.birthPlace;
+    expect(creator).toEqual<string>('');
+  });
+
+  test('Birthplace', () => {
+    const creator = getBirthdayInfo(asideNodeComposer)?.age;
+    expect(creator).toEqual(null);
+  });
+});
+
+describe("Creator's films", () => {
+  test('First film from first section', () => {
+    const films = getFilms(filmsNodeComposer) as CSFDCreatorScreening[];
+    expect(films[0].title).toEqual<string>('Spolu');
+  });
+});