node-csfd-api-racintom 1.6.0 → 1.8.0

package/src/helpers/movie.helper.ts

@@ -0,0 +1,276 @@
+import { HTMLElement } from 'node-html-parser';
+import { CSFDColorRating } from '../interfaces/global';
+import {
+  CSFDBoxContent,
+  CSFDCreator,
+  CSFDCreatorGroups,
+  CSFDGenres,
+  CSFDMovieListItem,
+  CSFDPremiere, CSFDSeasons,
+  CSFDTitlesOther,
+  CSFDVod,
+  CSFDVodService
+} from '../interfaces/movie.interface';
+import { addProtocol, getColor, parseISO8601Duration, parseIdFromUrl } from './global.helper';
+
+export const getId = (el: HTMLElement): number => {
+  const url = el.querySelector('.tabs .tab-nav-list a').attributes.href;
+  return parseIdFromUrl(url);
+};
+
+export const getTitle = (el: HTMLElement): string => {
+  return el.querySelector('h1').innerText.split(`(`)[0].trim();
+};
+
+export const getGenres = (el: HTMLElement): CSFDGenres[] => {
+  const genresRaw = el.querySelector('.genres').textContent;
+  return genresRaw.split(' / ') as CSFDGenres[];
+};
+
+export const getOrigins = (el: HTMLElement): string[] => {
+  const originsRaw = el.querySelector('.origin').textContent;
+  const origins = originsRaw.split(',')[0];
+  return origins.split(' / ');
+};
+
+export const getColorRating = (bodyClasses: string[]): CSFDColorRating => {
+  return getColor(bodyClasses[1]);
+};
+
+export const getRating = (el: HTMLElement): number => {
+  const ratingRaw = el.querySelector('.film-rating-average').textContent;
+  const rating = ratingRaw?.replace(/%/g, '').trim();
+  const ratingInt = parseInt(rating);
+
+  if (Number.isInteger(ratingInt)) {
+    return ratingInt;
+  } else {
+    return null;
+  }
+};
+
+export const getRatingCount = (el: HTMLElement): number => {
+  const ratingCountRaw = el.querySelector('.box-rating-container .counter')?.textContent;
+  const ratingCount = +ratingCountRaw?.replace(/[(\s)]/g, '');
+  if (Number.isInteger(ratingCount)) {
+    return ratingCount;
+  } else {
+    return null;
+  }
+};
+
+export const getYear = (el: string): number => {
+  try {
+    const jsonLd = JSON.parse(el);
+    return +jsonLd.dateCreated;
+  } catch (error) {
+    console.error('node-csfd-api: Error parsing JSON-LD', error);
+    return null;
+  }
+};
+
+export const getDuration = (jsonLdRaw: string, el: HTMLElement): number => {
+  let duration = null;
+  try {
+    const jsonLd = JSON.parse(jsonLdRaw);
+    duration = jsonLd.duration;
+    return parseISO8601Duration(duration);
+  } catch (error) {
+    const origin = el.querySelector('.origin').innerText;
+    const timeString = origin.split(',');
+    if (timeString.length > 2) {
+      // Get last time elelment
+      const timeString2 = timeString.pop().trim();
+      // Clean it
+      const timeRaw = timeString2.split('(')[0].trim();
+      // Split by minutes and hours
+      const hoursMinsRaw = timeRaw.split('min')[0];
+      const hoursMins = hoursMinsRaw.split('h');
+      // Resolve hours + minutes format
+      duration = hoursMins.length > 1 ? +hoursMins[0] * 60 + +hoursMins[1] : +hoursMins[0];
+      return duration;
+    } else {
+      return null;
+    }
+  }
+};
+
+export const getTitlesOther = (el: HTMLElement): CSFDTitlesOther[] => {
+  const namesNode = el.querySelectorAll('.film-names li');
+
+  if (!namesNode.length) {
+    return [];
+  }
+
+  const titlesOther = namesNode.map((el) => {
+    const country = el.querySelector('img.flag').attributes.alt;
+    const title = el.textContent.trim().split('\n')[0];
+
+    if (country && title) {
+      return {
+        country,
+        title
+      };
+    } else {
+      return null;
+    }
+  });
+
+  return titlesOther.filter((x) => x);
+};
+
+export const getPoster = (el: HTMLElement | null): string => {
+  const poster = el.querySelector('.film-posters img');
+  // Resolve empty image
+  if (poster) {
+    if (poster.classNames?.includes('empty-image')) {
+      return null;
+    } else {
+      // Full sized image (not thumb)
+      const imageThumb = poster.attributes.src.split('?')[0];
+      const image = imageThumb.replace(/\/w140\//, '/w1080/');
+      return addProtocol(image);
+    }
+  } else {
+    return null;
+  }
+};
+
+export const getRandomPhoto = (el: HTMLElement | null): string => {
+  const imageNode = el.querySelector('.gallery-item picture img');
+  const image = imageNode?.attributes?.src;
+  if (image) {
+    return image.replace(/\/w663\//, '/w1326/');
+  } else {
+    return null;
+  }
+};
+
+export const getTrivia = (el: HTMLElement | null): string[] => {
+  const triviaNodes = el.querySelectorAll('.article-trivia ul li');
+  if (triviaNodes?.length) {
+    return triviaNodes.map((node) => node.textContent.trim().replace(/(\r\n|\n|\r|\t)/gm, ''));
+  } else {
+    return null;
+  }
+};
+
+export const getDescriptions = (el: HTMLElement): string[] => {
+  return el
+    .querySelectorAll('.body--plots .plot-full p, .body--plots .plots .plots-item p')
+    .map((movie) => movie.textContent?.trim().replace(/(\r\n|\n|\r|\t)/gm, ''));
+};
+
+export const parsePeople = (el: HTMLElement): CSFDCreator[] => {
+  const people = el.querySelectorAll('a');
+  return (
+    people
+      // Filter out "more" links
+      .filter((x) => x.classNames.length === 0)
+      .map((person) => {
+        return {
+          id: parseIdFromUrl(person.attributes.href),
+          name: person.innerText.trim(),
+          url: `https://www.csfd.cz${person.attributes.href}`
+        };
+      })
+  );
+};
+
+export const getGroup = (el: HTMLElement, group: CSFDCreatorGroups): CSFDCreator[] => {
+  const creators = el.querySelectorAll('.creators h4');
+  const element = creators.filter((elem) => elem.textContent.trim().includes(group))[0];
+  if (element?.parentNode) {
+    return parsePeople(element.parentNode as HTMLElement);
+  } else {
+    return [];
+  }
+};
+
+export const getType = (el: HTMLElement): string => {
+  const type = el.querySelector('.film-header-name .type');
+  return type?.innerText?.replace(/[{()}]/g, '') || 'film';
+};
+
+export const getVods = (el: HTMLElement | null): CSFDVod[] => {
+  let vods: CSFDVod[] = [];
+  if (el) {
+    const buttons = el.querySelectorAll('.box-buttons .button');
+    const buttonsVod = buttons.filter((x) => !x.classNames.includes('button-social'));
+    vods = buttonsVod.map((btn) => {
+      return {
+        title: btn.textContent.trim() as CSFDVodService,
+        url: btn.attributes.href
+      };
+    });
+  }
+  return vods.length ? vods : [];
+};
+
+// Get box content
+export const getBoxContent = (el: HTMLElement, box: string): HTMLElement => {
+  const headers = el.querySelectorAll('section.box .box-header');
+  return headers.find((header) => header.querySelector('h3').textContent.trim().includes(box))
+    ?.parentNode;
+};
+
+export const getBoxMovies = (el: HTMLElement, boxName: CSFDBoxContent): CSFDMovieListItem[] => {
+  const movieListItem: CSFDMovieListItem[] = [];
+  const box = getBoxContent(el, boxName);
+  const movieTitleNodes = box?.querySelectorAll('.article-header .film-title-name');
+  if (movieTitleNodes?.length) {
+    for (const item of movieTitleNodes) {
+      movieListItem.push({
+        id: parseIdFromUrl(item.attributes.href),
+        title: item.textContent.trim(),
+        url: `https://www.csfd.cz${item.attributes.href}`
+      });
+    }
+  }
+  return movieListItem;
+};
+
+export const getPremieres = (el: HTMLElement): CSFDPremiere[] => {
+  const premiereNodes = el.querySelectorAll('.box-premieres li');
+  const premiere: CSFDPremiere[] = [];
+  for (const premiereNode of premiereNodes) {
+    const title = premiereNode.querySelector('p + span').attributes.title;
+
+    if (title) {
+      const [date, ...company] = title?.split(' ');
+
+      premiere.push({
+        country: premiereNode.querySelector('.flag')?.attributes.title || null,
+        format: premiereNode.querySelector('p').textContent.trim()?.split(' od')[0],
+        date,
+        company: company.join(' ')
+      });
+    }
+  }
+  return premiere;
+};
+
+export const getTags = (el: HTMLElement): string[] => {
+  const tagsRaw = el.querySelectorAll('.box-content a[href*="/podrobne-vyhledavani/?tag="]');
+  return tagsRaw.map((tag) => tag.textContent);
+};
+
+export const getSeasonsInfo = (el: HTMLElement): CSFDSeasons => {
+  const seasonsList = el.querySelector('.film-episodes-list')
+  if (seasonsList === null) {
+    return null
+  }
+
+  const seasons = seasonsList.querySelectorAll('.film-title')
+
+  return seasons.map(season => {
+    const nameContainer = season.querySelector('.film-title-name')
+    const infoContainer = season.querySelector('.film-title-info')
+
+    return {
+      linkToDetail: nameContainer.getAttribute('href'),
+      name: nameContainer.textContent,
+      additionalInfo: infoContainer.textContent
+    }
+  })
+}

package/src/helpers/search-user.helper.ts

@@ -0,0 +1,19 @@
+import { HTMLElement } from 'node-html-parser';
+import { addProtocol } from './global.helper';
+
+export const getUser = (el: HTMLElement): string => {
+  return el.querySelector('.user-title-name').text;
+};
+
+export const getUserRealName = (el: HTMLElement): string => {
+  return el.querySelector('.user-real-name')?.text.trim() || null;
+};
+
+export const getAvatar = (el: HTMLElement): string => {
+  const image = el.querySelector('.article-img img').attributes.src;
+  return addProtocol(image);
+};
+
+export const getUserUrl = (el: HTMLElement): string => {
+  return el.querySelector('.user-title-name').attributes.href;
+};

package/src/helpers/search.helper.ts

@@ -0,0 +1,66 @@
+import { HTMLElement } from 'node-html-parser';
+import { CSFDColorRating, CSFDFilmTypes } from '../interfaces/global';
+import { CSFDCreator } from '../interfaces/movie.interface';
+import { Colors } from '../interfaces/user-ratings.interface';
+import { addProtocol, parseColor, parseIdFromUrl } from './global.helper';
+
+type Creator = 'Režie:' | 'Hrají:';
+
+export const getType = (el: HTMLElement): CSFDFilmTypes => {
+  const type = el.querySelectorAll('.film-title-info .info')[1];
+  return (type?.innerText.replace(/[{()}]/g, '') || 'film') as CSFDFilmTypes;
+};
+
+export const getTitle = (el: HTMLElement): string => {
+  return el.querySelector('.film-title-name').text;
+};
+
+export const getYear = (el: HTMLElement): number => {
+  return +el.querySelectorAll('.film-title-info .info')[0]?.innerText.replace(/[{()}]/g, '');
+};
+
+export const getUrl = (el: HTMLElement): string => {
+  return el.querySelector('.film-title-name').attributes.href;
+};
+
+export const getColorRating = (el: HTMLElement): CSFDColorRating => {
+  return parseColor(
+    el.querySelector('.article-header i.icon').classNames.split(' ').pop() as Colors
+  );
+};
+
+export const getPoster = (el: HTMLElement): string => {
+  const image = el.querySelector('img').attributes.src;
+  return addProtocol(image);
+};
+
+export const getOrigins = (el: HTMLElement): string[] => {
+  const originsRaw = el.querySelector('.article-content p .info')?.text;
+  if (!originsRaw) return [];
+  const originsAll = originsRaw?.split(', ')?.[0];
+  return originsAll?.split('/').map((country) => country.trim());
+};
+
+export const parsePeople = (el: HTMLElement, type: 'directors' | 'actors'): CSFDCreator[] => {
+  let who: Creator;
+  if (type === 'directors') who = 'Režie:';
+  if (type === 'actors') who = 'Hrají:';
+
+  const peopleNode = Array.from(el && el.querySelectorAll('.article-content p')).find((el) =>
+    el.textContent.includes(who)
+  );
+
+  if (peopleNode) {
+    const people = Array.from(peopleNode.querySelectorAll('a')) as unknown as HTMLElement[];
+
+    return people.map((person) => {
+      return {
+        id: parseIdFromUrl(person.attributes.href),
+        name: person.innerText.trim(),
+        url: `https://www.csfd.cz${person.attributes.href}`
+      };
+    });
+  } else {
+    return [];
+  }
+};

package/src/helpers/user-ratings.helper.ts

@@ -0,0 +1,62 @@
+import { HTMLElement } from 'node-html-parser';
+import { CSFDColorRating, CSFDFilmTypes, CSFDStars } from '../interfaces/global';
+import { Colors } from '../interfaces/user-ratings.interface';
+import { parseIdFromUrl } from './global.helper';
+
+export const getId = (el: HTMLElement): number => {
+  const url = el.querySelector('td.name .film-title-name').attributes.href;
+  return parseIdFromUrl(url);
+};
+
+export const getUserRating = (el: HTMLElement): CSFDStars => {
+  const ratingText = el.querySelector('td.star-rating-only .stars').classNames.split(' ').pop();
+
+  const rating = ratingText.includes('stars-') ? +ratingText.split('-').pop() : 0;
+  return rating as CSFDStars;
+};
+
+export const getType = (el: HTMLElement): CSFDFilmTypes => {
+  const typeText = el.querySelectorAll('td.name .film-title-info .info');
+
+  return (typeText.length > 1 ? typeText[1].text.slice(1, -1) : 'film') as CSFDFilmTypes;
+};
+
+export const getTitle = (el: HTMLElement): string => {
+  return el.querySelector('td.name .film-title-name').text;
+};
+
+export const getYear = (el: HTMLElement): number => {
+  return +el.querySelectorAll('td.name .film-title-info .info')[0]?.text.slice(1, -1) || null;
+};
+
+export const getColorRating = (el: HTMLElement): CSFDColorRating => {
+  const color = parseColor(el.querySelector('td.name .icon').classNames.split(' ').pop() as Colors);
+  return color;
+};
+
+export const getDate = (el: HTMLElement): string => {
+  return el.querySelector('td.date-only').text.trim();
+};
+
+export const getUrl = (el: HTMLElement): string => {
+  const url = el.querySelector('td.name .film-title-name').attributes.href;
+  return `https://www.csfd.cz${url}`;
+};
+
+export const parseColor = (quality: Colors): CSFDColorRating => {
+  switch (quality) {
+    case 'lightgrey':
+      return 'unknown';
+    case 'red':
+      return 'good';
+    case 'blue':
+      return 'average';
+    case 'grey':
+      return 'bad';
+    default:
+      return 'unknown';
+  }
+};
+
+// Sleep in loop
+export const sleep = (ms: number) => new Promise((res) => setTimeout(res, ms));

package/src/index.ts

@@ -0,0 +1,50 @@
+import { CSFDCreator } from './interfaces/creator.interface';
+import { CSFDMovie } from './interfaces/movie.interface';
+import { CSFDSearch } from './interfaces/search.interface';
+import { CSFDUserRatingConfig, CSFDUserRatings } from './interfaces/user-ratings.interface';
+import { CreatorScraper } from './services/creator.service';
+import { MovieScraper } from './services/movie.service';
+import { SearchScraper } from './services/search.service';
+import { UserRatingsScraper } from './services/user-ratings.service';
+import { SeasonScraper } from './services/season.service';
+import { CSFDSeason } from './interfaces/season.interface';
+
+export class Csfd {
+  constructor(
+    private userRatingsService: UserRatingsScraper,
+    private movieService: MovieScraper,
+    private creatorService: CreatorScraper,
+    private searchService: SearchScraper,
+    private seasonService: SeasonScraper,
+  ) {}
+
+  public async userRatings(
+    user: string | number,
+    config?: CSFDUserRatingConfig
+  ): Promise<CSFDUserRatings[]> {
+    return this.userRatingsService.userRatings(user, config);
+  }
+
+  public async movie(movie: number): Promise<CSFDMovie> {
+    return this.movieService.movie(+movie);
+  }
+
+  public async creator(creator: number): Promise<CSFDCreator> {
+    return this.creatorService.creator(+creator);
+  }
+
+  public async search(text: string): Promise<CSFDSearch> {
+    return this.searchService.search(text);
+  }
+
+  public async seasonDetails(url: string): Promise<CSFDSeason> {
+    return this.seasonService.season(url);
+  }
+}
+
+const movieScraper = new MovieScraper();
+const userRatingsScraper = new UserRatingsScraper();
+const creatorScraper = new CreatorScraper();
+const searchScraper = new SearchScraper();
+const seasonScraper = new SeasonScraper();
+export const csfd = new Csfd(userRatingsScraper, movieScraper, creatorScraper, searchScraper, seasonScraper);

package/src/interfaces/creator.interface.ts

@@ -0,0 +1,14 @@
+import { CSFDScreening } from './global';
+
+export interface CSFDCreator {
+  id: number;
+  name: string;
+  birthday: string;
+  birthplace: string;
+  photo: string;
+  age: number | string;
+  bio: string;
+  films: CSFDCreatorScreening[];
+}
+
+export type CSFDCreatorScreening = Omit<CSFDScreening, 'url' | 'type'>;

package/src/interfaces/global.ts

@@ -0,0 +1,36 @@
+export interface CSFDScreening {
+  id: number;
+  title: string;
+  year: number;
+  url: string;
+  type: CSFDFilmTypes;
+  /**
+   * Overall aggregated rating. (On the web usually represented by colors).
+   *
+   * 'unknown': unknown (gray color)
+   *
+   * 'good': 70% – 100 % (red color)
+   *
+   * 'average': 30% - 69% (blue color)
+   *
+   * 'bad': 0% - 29% (black color)
+   */
+  colorRating: CSFDColorRating;
+}
+
+export type CSFDColorRating = 'bad' | 'average' | 'good' | 'unknown';
+
+export type CSFDStars = 0 | 1 | 2 | 3 | 4 | 5;
+
+export type CSFDFilmTypes =
+  | 'film'
+  | 'TV film'
+  | 'pořad'
+  | 'seriál'
+  | 'divadelní záznam'
+  | 'koncert'
+  | 'série'
+  | 'studentský film'
+  | 'amatérský film'
+  | 'hudební videoklip'
+  | 'epizoda';

package/src/interfaces/movie.interface.ts

@@ -0,0 +1,157 @@
+import { CSFDScreening } from './global';
+
+export interface CSFDMovie extends CSFDScreening {
+  rating: number | null;
+  poster: string;
+  photo: string;
+  ratingCount: number | null;
+  duration: number | string;
+  titlesOther: CSFDTitlesOther[];
+  origins: string[];
+  descriptions: string[];
+  trivia: string[];
+  genres: CSFDGenres[] | string[];
+  creators: CSFDCreators;
+  vod: CSFDVod[];
+  tags: string[];
+  premieres: CSFDPremiere[];
+  related: CSFDMovieListItem[];
+  similar: CSFDMovieListItem[];
+  seasons: CSFDSeasons | null;
+}
+
+export type CSFDVodService =
+  | 'Netflix'
+  | 'hbogo'
+  | 'Prime Video'
+  | 'Apple TV+'
+  | 'iTunes'
+  | 'KVIFF.TV'
+  | 'Edisonline'
+  | 'o2tv'
+  | 'SledovaniTV'
+  | 'Starmax'
+  | 'DAFilms'
+  | 'FILMY ČESKY A ZADARMO'
+  | 'Youtube Česká filmová klasika'
+  | 'VAPET'
+  | 'VOREL FILM'
+  | 'ivysilani'
+  | 'Google Play'
+  | 'Voyo'
+  | 'DVD';
+
+export interface CSFDVod {
+  title: CSFDVodService;
+  url: string;
+}
+
+export interface CSFDCreators {
+  directors: CSFDCreator[];
+  writers: CSFDCreator[];
+  cinematography: CSFDCreator[];
+  music: CSFDCreator[];
+  actors: CSFDCreator[];
+  basedOn: CSFDCreator[];
+  producers: CSFDCreator[];
+  filmEditing: CSFDCreator[];
+  costumeDesign: CSFDCreator[];
+  productionDesign: CSFDCreator[];
+}
+
+export interface CSFDTitlesOther {
+  country: string;
+  title: string;
+}
+
+export interface CSFDCreator {
+  /**
+   * CSFD person ID.
+   *
+   * You can always assemble url from ID like this:
+   *
+   * `https://www.csfd.cz/tvurce/${id}`
+   */
+  id: number;
+  name: string;
+  url: string;
+}
+
+export interface CSFDMovieListItem {
+  id: number;
+  title: string;
+  url: string;
+}
+
+export type CSFDGenres =
+  | 'Akční'
+  | 'Animovaný'
+  | 'Dobrodružný'
+  | 'Dokumentární'
+  | 'Drama'
+  | 'Experimentální'
+  | 'Fantasy'
+  | 'Film-Noir'
+  | 'Historický'
+  | 'Horor'
+  | 'Hudební'
+  | 'IMAX'
+  | 'Katastrofický'
+  | 'Komedie'
+  | 'Krátkometrážní'
+  | 'Krimi'
+  | 'Loutkový'
+  | 'Muzikál'
+  | 'Mysteriózní'
+  | 'Naučný'
+  | 'Podobenství'
+  | 'Poetický'
+  | 'Pohádka'
+  | 'Povídkový'
+  | 'Psychologický'
+  | 'Publicistický'
+  | 'Reality-TV'
+  | 'Road movie'
+  | 'Rodinný'
+  | 'Romantický'
+  | 'Sci-Fi'
+  | 'Soutěžní'
+  | 'Sportovní'
+  | 'Stand-up'
+  | 'Talk-show'
+  | 'Taneční'
+  | 'Telenovela'
+  | 'Thriller'
+  | 'Válečný'
+  | 'Western'
+  | 'Zábavný'
+  | 'Životopisný';
+
+export type CSFDCreatorGroups =
+  | 'Režie'
+  | 'Scénář'
+  | 'Kamera'
+  | 'Hudba'
+  | 'Hrají'
+  | 'Produkce'
+  | 'Střih'
+  | 'Předloha'
+  | 'Scénografie'
+  | 'Kostýmy';
+
+export interface CSFDPremiere {
+  country: string;
+  format: string;
+  date: string;
+  company: string;
+}
+
+export type CSFDBoxContent = 'Související' | 'Podobné';
+
+export type CSFDSeasons = CSFDSeasonInfo[]
+
+export interface CSFDSeasonInfo {
+  name: string
+  linkToDetail: string
+  additionalInfo: string
+}