FROM apify/actor-node:16

COPY package.json ./

RUN npm --quiet set progress=false \
 &amp;&amp; npm install --only=prod --no-optional

COPY . ./

Dockerfile

{
 "title": "FDF Bike Shop (fdfbikeshop.cz) scraper",
 "description": "Scrapes products titles, prices, images and availability. Does NOT scrape product details.",
 "type": "object",
 "schemaVersion": 1,
 "properties": {
 "mode": {
 "title": "Mode",
 "description": "",
 "type": "string",
 "editor": "select",
 "default": "TEST",
 "prefill": "TEST",
 "enum": [
 "TEST",
 "FULL"
 ],
 "enumTitles": [
 "TEST",
 "FULL"
 ]
 },
 "APIFY_DONT_STORE_IN_DATASET": {
 "sectionCaption": "Advanced",
 "sectionDescription": "Advanced options, use only if you know what you're doing.",
 "title": "Don't store in dataset",
 "description": "If set to true, the actor will not store the results in the default dataset. Useful when using alternative storage, like own database",
 "type": "boolean",
 "default": false,
 "editor": "checkbox"
 },
 "PG_CONNECTION_STRING_NORMALIZED": {
 "title": "Postgres connection string for normalized data",
 "description": "If set, actor will store normalized data in Postgres database in PG_DATA_TABLE and PG_DATA_PRICE_TABLE tables",
 "type": "string",
 "editor": "textfield"
 },
 "PG_DATA_TABLE": {
 "title": "Postgres table name for product data",
 "description": "Table name for storing product name, url, image, ...",
 "type": "string",
 "editor": "textfield"
 },
 "PG_DATA_PRICE_TABLE": {
 "title": "Postgres table name for price data",
 "description": "Table name for storing price, original price, stock status, ...",
 "type": "string",
 "editor": "textfield"
 }
 },
 "required": [
 "mode"
 ]
}

INPUT_SCHEMA.json

# FDF Bike Shop (fdfbikeshop.cz) scraper

Scrapes products titles, prices, images and availability. Does NOT scrape product details.

## Output example

* **pid** `string` e.g. *16678*
* **name** `string` e.g. *SHIMANO pedály PD-M520*
* **url** `string` e.g. *https://www.fdfbikeshop.cz/naslapne/shimano-pedaly-pd-m520/*
* **img** `string` e.g. *https://cdn.myshoptet.com/usr/www.fdfbikeshop.cz/user/shop/detail_small/16678_shimano-pedaly-pd-m520-cerne-v.jpg?622b077c*
* **inStock** `boolean` e.g. *true*
* **currentPrice** `number` e.g. *599*
* **originalPrice** `number` e.g. *799*
* **currency** `string` e.g. *CZK*

README.md

{
 "name": "fdf-bike-shop-fdfbikeshop-cz-scraper",
 "version": "0.1",
 "buildTag": "latest",
 "env": null,
 "defaultRunOptions": {
 "build": "latest",
 "timeoutSecs": 3600,
 "memoryMbytes": 1024
 }
}

apify.json

main.js

{
 "name": "fdf-bike-shop-fdfbikeshop-cz-scraper",
 "description": "Scrapes products titles, prices, images and availability. Does NOT scrape product details.",
 "type": "module",
 "scripts": {
 "start": "node ./main.js",
 "push-to-apify-platform": "npx apify push"
 },
 "dependencies": {
 "apify3": "npm:apify@^3.0.2",
 "crawlee": "*",
 "pg": "*",
 "pg-connection-string": "*",
 "dotenv": "*",
 "find-config": "*",
 "@elastic/elasticsearch": "*",
 "filenamify": "*"
 },
 "apify": {
 "title": "FDF Bike Shop (fdfbikeshop.cz) scraper",
 "description": "Scrapes products titles, prices, images and availability. Does NOT scrape product details.",
 "isPublic": true,
 "isDeprecated": false,
 "isAnonymouslyRunnable": true,
 "notice": "",
 "pictureUrl": "",
 "seoTitle": "",
 "seoDescription": "",
 "categories": [
 "ECOMMERCE"
 ]
 }
}

package.json

{
 "actorSpecification": 1,
 "name": "fdf-bike-shop-fdfbikeshop-cz-scraper",
 "title": "FDF Bike Shop (fdfbikeshop.cz) scraper",
 "description": "Scrapes products titles, prices, images and availability. Does NOT scrape product details.",
 "version": "0.1.0",
 "storages": {
 "dataset": {
 "actorSpecification": 1,
 "title": "FDF Bike Shop (fdfbikeshop.cz) scraper",
 "description": "Scrapes products titles, prices, images and availability. Does NOT scrape product details.",
 "views": {
 "overview": {
 "title": "Overview",
 "description": "Overview of the most important fields",
 "transformation": {
 "fields": [
 "pid",
 "name",
 "url",
 "img",
 "inStock",
 "currentPrice",
 "originalPrice",
 "currency"
 ]
 },
 "display": {
 "component": "table",
 "columns": [
 {
 "label": "Pid",
 "field": "pid",
 "format": "text"
 },
 {
 "label": "Name",
 "field": "name",
 "format": "text"
 },
 {
 "label": "Url",
 "field": "url",
 "format": "link"
 },
 {
 "label": "Img",
 "field": "img",
 "format": "image"
 },
 {
 "label": "In Stock",
 "field": "inStock",
 "format": "boolean"
 },
 {
 "label": "Current Price",
 "field": "currentPrice",
 "format": "number"
 },
 {
 "label": "Original Price",
 "field": "originalPrice",
 "format": "number"
 },
 {
 "label": "Currency",
 "field": "currency",
 "format": "text"
 }
 ]
 }
 }
 }
 }
 }
}

.actor/actor.json

.actor/logo.png

_utils/common.js

FROM apify/actor-node:16

COPY package.json ./

RUN npm --quiet set progress=false \
  && npm install --only=prod --no-optional

COPY . ./

Scrapes products titles, prices, images and availability. Does NOT scrape product details.

If set to true, the actor will not store the results in the default dataset. Useful when using alternative storage, like own database

Advanced options, use only if you know what you're doing.

Don't store in dataset

If set, actor will store normalized data in Postgres database in PG_DATA_TABLE and PG_DATA_PRICE_TABLE tables

Postgres connection string for normalized data

Table name for storing price, original price, stock status, ...

Postgres table name for price data

Table name for storing product name, url, image, ...

Postgres table name for product data

Mode

FDF Bike Shop (fdfbikeshop.cz) scraper

# FDF Bike Shop (fdfbikeshop.cz) scraper

Scrapes products titles, prices, images and availability. Does NOT scrape product details.

## Output example

* **pid** `string` e.g. *16678*
* **name** `string` e.g. *SHIMANO pedály PD-M520*
* **url** `string` e.g. *https://www.fdfbikeshop.cz/naslapne/shimano-pedaly-pd-m520/*
* **img** `string` e.g. *https://cdn.myshoptet.com/usr/www.fdfbikeshop.cz/user/shop/detail_small/16678_shimano-pedaly-pd-m520-cerne-v.jpg?622b077c*
* **inStock** `boolean` e.g. *true*
* **currentPrice** `number` e.g. *599*
* **originalPrice** `number` e.g. *799*
* **currency** `string` e.g. *CZK*

fdf-bike-shop-fdfbikeshop-cz-scraper

import { Actor } from "apify3";
import { CheerioCrawler, createCheerioRouter } from "crawlee";
import { init, save, toNumberOrNull } from "./_utils/common.js";

const LABELS = {
 INDEX: `INDEX`,
 PRODUCTS: `PRODUCTS`,
};

var MODE;

(function (MODE) {
 MODE["TEST"] = "TEST";
 MODE["FULL"] = "FULL";
})(MODE || (MODE = {}));

const baseUrl = `https://www.fdfbikeshop.cz`;

async function enqueueInitial(mode, crawler) {
 if (mode === MODE.FULL) {
 await crawler.addRequests([
 {
 userData: { label: LABELS.INDEX },
 url: `${baseUrl}/sitemap.xml`,
 },
 ]);
 } else if (mode === MODE.TEST) {
 await crawler.addRequests([
 {
 userData: { label: LABELS.PRODUCTS },
 url: `${baseUrl}/znacka/crankbrothers/`,
 },
 ]);
 await crawler.addRequests([
 {
 userData: { label: LABELS.PRODUCTS },
 url: `${baseUrl}/znacka/dt-swiss/`,
 },
 ]);
 await crawler.addRequests([
 {
 userData: { label: LABELS.PRODUCTS },
 url: `${baseUrl}/znacka/galfer/`,
 },
 ]);
 }
}

const router = createCheerioRouter();

router.addHandler(LABELS.INDEX, async ({ $, crawler }) => {
 const urls = $(`url loc`)
 .map((i, x) => $(x).text())
 .toArray();
 // https://www.fdfbikeshop.cz/znacka/100/ » brands, only type of urls we are interested in
 // https://www.fdfbikeshop.cz/nahradni-dily-loziska/
 // https://www.fdfbikeshop.cz/kazety-12sp/
 // @ts-ignore
 const brandsUrls = urls.filter((url) => url?.includes(`/znacka/`));
 const requests = [];
 for (const url of brandsUrls) {
 requests.push({
 userData: { label: LABELS.PRODUCTS },
 // @ts-ignore
 url,
 });
 }
 await crawler.addRequests(requests);
});

router.addHandler(LABELS.PRODUCTS, async ({ $, crawler, request }) => {
 console.log(`Processing ${request.url}`);

 // on first page » handle pagination
 if (!request.url.match(/\/strana-\d+\//)) {
 // /znacka/fox/strana-2/
 let totalPages;
 try {
 totalPages = parseInt(
 // $('.pagination-description-pages:eq(0) strong:eq(1)').text() » this does not work
 $(`.pagination-description-pages`).eq(0).find(`strong`).eq(1).text()
 );
 } catch (e) {
 totalPages = 1;
 }
 if (totalPages > 1) {
 console.log(`> …found ${totalPages} pages, enqueuing them…`);
 }
 for (let i = 2; i <= totalPages; i++) {
 // skip first page, that is already handled
 void crawler.addRequests([
 {
 userData: { label: LABELS.PRODUCTS },
 url: `${request.url}strana-${i}/`,
 },
 ]);
 }
 }

 const products = [];
 $(`#category-products-wrapper .product`).each((i, el) => {
 const id = $(el).attr(`data-micro-product-id`); // e.g. 20080005-40200770

 const relUrl = $(el).find(`a.p-name`).attr(`href`);
 const url = `${baseUrl}${relUrl}`;
 const title = $(el).find(`[data-micro='name']`).text();

 const priceRaw = $(el).find(`.p-det-main-price`).text().trim(); // e.g. `39 990 Kč`
 const price = priceRaw.replace(/[^\d,]/g, ``); // keep comma as it's decimal separator

 const priceOrigRaw = $(el)
 .find(`.p-standard-price span.line`)
 .text()
 .trim();
 const priceOrig = priceOrigRaw.replace(/[^\d,]/g, ``);

 const img = $(el).find(`img[data-micro='image']`).attr(`src`);

 let inStock = false;
 try {
 inStock = $(el).find(`.p-cat-availability`).text().includes(`Skladem`);
 } catch (err) {
 // ignore
 }

 const product = {
 pid: id,
 name: title,
 url: url,
 img: img,
 inStock,
 currentPrice: toNumberOrNull(price),
 originalPrice: toNumberOrNull(priceOrig),
 currency: `CZK`,
 };
 products.push(product);
 });
 void save(products);
});

void Actor.main(async () => {
 const input = await Actor.getInput();
 const { mode = MODE.FULL, ...rest } = input ?? {};
 await init({ actorNameOverride: `fdfbikeshop-cz` }, rest);
 const crawler = new CheerioCrawler({ requestHandler: router });
 await enqueueInitial(mode, crawler);
 await crawler.run();
});

import { createHash } from 'crypto'
import os from "os"
import path from "path"
// eslint-disable-next-line @apify/apify-actor/no-forbidden-node-internals
import fs from "fs"
import pg from "pg"
import pgConnectionString from 'pg-connection-string'
import { config } from 'dotenv'
import findConfig from "find-config"
import { Client as ElasticClient } from "@elastic/elasticsearch"
import filenamify from 'filenamify'
import { Dataset } from 'crawlee'

config({ path: findConfig(`.env`) })

const elasticIndexName = `actors-monorepo-shops`

const globalLogsProps = {
 __NODE_STARTED: new Date().toISOString(),
}

let actorName
let pgClient
let pgClientNormalized
let elasticClient
export async function init ({ actorNameOverride }, restInput) {
 parseEnvFromInput(restInput)

 if (os.platform() === `darwin`) {
 const filePath = process.argv[1] // ~/Projects/apify-actors-monorepo/actors/foo.ts
 const basename = path.basename(filePath) // foo.ts
 actorName = actorNameOverride ?? basename.split(`.`)[0] // foo
 const gitBranch = fs.readFileSync(path.join(process.cwd(), `..`, `.git/HEAD`), `utf8`)
 .split(` `)[1]
 .trim()
 .replace(`refs/heads/`, ``)
 const gitCommit = fs.readFileSync(path.join(process.cwd(), `..`, `.git/refs/heads/${gitBranch}`), `utf8`)
 const gitCommitShort = gitCommit.substring(0, 7)
 globalLogsProps.__GIT_COMMIT = gitCommitShort
 }

 if (process.env.APIFY_IS_AT_HOME) {
 actorName = actorNameOverride ?? process.env.APIFY_ACTOR_ID // Name would be better, but it's not in ENV
 }

 /* ELASTIC */
 /* ======= */
 if (process.env.ELASTIC_CLOUD_ID) {
 elasticClient = new ElasticClient({
 cloud: { id: process.env.ELASTIC_CLOUD_ID },
 auth: { apiKey: process.env.ELASTIC_CLOUD_API_KEY },
 })

 // const mapping = await elasticClient.indices.getMapping({ index: actorName })

 // eslint-disable-next-line no-inner-declarations
 async function enforceIndexMapping () {
 const doesIndexExist = await elasticClient.indices.exists({ index: elasticIndexName })
 if (!doesIndexExist) await elasticClient.indices.create({ index: elasticIndexName })
 await elasticClient.indices.putMapping({
 index: elasticIndexName,
 body: {
 properties: {
 _discount: { type: `float` },
 originalPrice: { type: `float` },
 currentPrice: { type: `float` },
 },
 },
 })
 }

 try {
 await enforceIndexMapping()
 } catch (err) {
 if (err.message.includes(`cannot be changed from type`)) {
 console.log(`Elastic index ${elasticIndexName} already exists with incorrect mappings. As existing mapping cannot be changed, index will be deleted and recreated.`)
 await elasticClient.indices.delete({ index: elasticIndexName })
 await enforceIndexMapping()
 }
 }
 }

 /* POSTGRESQL */
 /* ========== */
 if (process.env.PG_CONNECTION_STRING) {
 const pgConfig = pgConnectionString(process.env.PG_CONNECTION_STRING)
 // const pgPool = new pg.Pool(pgConfig)

 pgClient = new pg.Client(pgConfig)
 await pgClient.connect()

 // Check if table exists and have proper columns
 const { rows: tables } = await pgClient.query(`
 SELECT table_name
 FROM information_schema.tables
 WHERE table_schema = 'public'
 `)

 // eslint-disable-next-line camelcase
 const tableExists = tables.some(({ table_name }) => table_name === process.env.PG_DATA_TABLE)
 if (!tableExists) {
 throw new Error(`Table ${process.env.PG_DATA_TABLE} does not exist in database ${pgConfig.database}`)
 }

 // TODO: Handle pgClient closing
 }

 if (process.env.PG_CONNECTION_STRING_NORMALIZED) {
 const pgConfig = pgConnectionString(process.env.PG_CONNECTION_STRING_NORMALIZED)

 pgClientNormalized = new pg.Client(pgConfig)
 await pgClientNormalized.connect()

 // Check if table exists and have proper columns
 const { rows: tables } = await pgClientNormalized.query(`
 SELECT table_name
 FROM information_schema.tables
 WHERE table_schema = 'public'
 `)

 // eslint-disable-next-line camelcase
 const tableMainExists = tables.some(({ table_name }) => table_name === process.env.PG_DATA_TABLE)
 // eslint-disable-next-line camelcase
 const tablePricesExists = tables.some(({ table_name }) => table_name === process.env.PG_DATA_PRICE_TABLE)
 if (!tableMainExists) throw new Error(`Table ${process.env.PG_DATA_TABLE} does not exist in database ${pgConfig.database}`)
 if (!tablePricesExists) throw new Error(`Table ${process.env.PG_DATA_PRICE_TABLE} does not exist in database ${pgConfig.database}`)

 // TODO: Handle pgClient closing
 }
}

// inspired by @drobnikj
// TODO: Similar, but less obfuscated for easier debugging
export const createUniqueKeyFromUrl = (url) => {
 const hash = createHash(`sha256`)
 const cleanUrl = url.split(`://`)[1] // Remove protocol
 hash.update(cleanUrl)
 return hash.digest(`hex`)
}

/**
 *
 * @param {Date} datetime
 * @return {Promise<void>}
 */
export const sleepUntil = async (datetime) => {
 const now = new Date()
 const difference = datetime - now
 if (difference > 0) {
 return new Promise((resolve) => {
 setTimeout(resolve, difference)
 })
 }
 return Promise.resolve()
}

export function parsePrice (string) {
 let amount, currency
 const noText = string.replace(/[^\d,.]/g, ``)
 const decimals = noText.match(/([,.])(\d{2})$/)
 if (decimals) {
 const decimalSeparator = decimals[1]
 // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
 const decimalAmount = decimals[2]
 amount = parseInt(noText.split(decimalSeparator)[0])
 } {
 const justNumbers = noText.replace(/[,.]/g, ``)
 amount = parseInt(justNumbers)
 }
 return { amount, currency }
}

export function toNumberOrNull (str) {
 // TODO: Handle better, but only after adding test
 if (str === undefined) return null
 if (str === null) return null
 if (str === ``) return null
 const num = Number(str)
 if (Number.isNaN(num)) return null
 return num
}

export async function save (objs) {
 if (!Array.isArray(objs)) objs = [objs]
 if (objs.length === 0) return

 const objsExtended = objs.map((obj) => {
 const objExtended = {
 ...obj,
 actorName,
 ...globalLogsProps,
 // __NODE_VERSION: global.process.versions.node,
 // __NODE_UPTIME: global.process.uptime().toFixed(2), // seconds, 2 decimals
 }
 // if run on Apify
 if (process.env.APIFY_IS_AT_HOME) {
 objExtended.__APIFY_ACTOR_ID = process.env.APIFY_ACTOR_ID
 objExtended.__APIFY_ACTOR_RUN_ID = process.env.APIFY_ACTOR_RUN_ID
 objExtended.__APIFY_ACTOR_BUILD_ID = process.env.APIFY_ACTOR_BUILD_ID
 objExtended.__APIFY_ACTOR_BUILD_NUMBER = process.env.APIFY_ACTOR_BUILD_NUMBER
 objExtended.__APIFY_ACTOR_TASK_ID = process.env.APIFY_ACTOR_TASK_ID
 if (!process.env.APIFY_DONT_STORE_IN_DATASET) void Dataset.pushData(obj)
 }
 return objExtended
 })
 // if runs on local machine (MacOS)
 if (os.platform() === `darwin`) {
 const cwd = process.cwd() // ~/Projects/apify-actors-monorepo/actors
 const storageDir = path.join(cwd, `${actorName}.storage`) // ~/Projects/apify-actors-monorepo/actors/foo.storage
 if (!fs.existsSync(storageDir)) fs.mkdirSync(storageDir)
 const dataDir = path.join(storageDir, `data`) // ~/Projects/apify-actors-monorepo/actors/foo.storage/data
 if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir)
 for (const objExtended of objsExtended) {
 const id = objExtended.id ?? objExtended.pid // ?? uuidv4()
 const fileName = `${filenamify(id)}.json`
 const dataFilePath = path.join(dataDir, fileName) // ~/Projects/apify-actors-monorepo/actors/foo.storage/data/foo.json
 fs.writeFileSync(dataFilePath, JSON.stringify(objExtended, null, 2))
 }
 }

 if (pgClient) {
 const objsPg = objs.map((obj) => ({
 ...obj,
 // TODO: This is becoming not nice, and not clear
 shop: actorName,
 scrapedAt: new Date().toISOString().split(`T`)[0],
 }))

 const columns = getColumns(objsPg)
 const values = getValues(objsPg)
 const queryString = `
 INSERT INTO public."${process.env.PG_DATA_TABLE}" (${columns})
 VALUES (${values})
 `
 try {
 const { rowCount } = await pgClient.query(queryString)
 console.log(`[save] saved to database: ${JSON.stringify(rowCount)}`)
 } catch (err) {
 if (err.message.includes(`violates unique constraint`)) console.warn(`PostgresSQL: violates unique constraint`)
 else throw err
 }
 }

 // Only make sense for HlidacShopu
 if (pgClientNormalized) {
 const objsPgData = objs.map((obj) => ({
 shop: actorName,
 pid: obj.pid,
 name: obj.name,
 url: obj.url,
 img: obj.img,
 }))

 const objsPgDataPrice = objs.map((obj) => ({
 shop: actorName,
 pid: obj.pid,
 scrapedAt: new Date().toISOString().split(`T`)[0],
 currentPrice: obj.currentPrice,
 originalPrice: obj.originalPrice,
 inStock: obj.inStock,
 }))

 const queryString = `
 INSERT INTO public."${process.env.PG_DATA_TABLE}" (${getColumns(objsPgData)})
 VALUES (${getValues(objsPgData)})
 ON CONFLICT DO NOTHING
 `
 try {
 const { rowCount } = await pgClientNormalized.query(queryString)
 console.log(`[save] saved to database (data): ${JSON.stringify(rowCount)}`)
 } catch (err) {
 if (err.message.includes(`violates unique constraint`)) console.warn(`PostgresSQL: violates unique constraint`)
 else throw err
 }

 const queryStringPrice = `
 INSERT INTO public."${process.env.PG_DATA_PRICE_TABLE}" (${getColumns(objsPgDataPrice)})
 VALUES (${getValues(objsPgDataPrice)})
 ON CONFLICT DO NOTHING
 `
 try {
 const { rowCount } = await pgClientNormalized.query(queryStringPrice)
 console.log(`[save] saved to database (price): ${JSON.stringify(rowCount)}`)
 } catch (err) {
 if (err.message.includes(`violates unique constraint`)) console.warn(`PostgresSQL: violates unique constraint`)
 else throw err
 }
 }

 if (elasticClient) {
 // .index creates or updates the document
 // .create creates a new document if it doesn't exist, 409 if it does
 // try {
 // const res = await elasticClient.index({
 // index: `actors-monorepo-shops`, // TODO: Consider using actorName
 // id, // foo-bar
 // document: objExtended, // {...}
 // })
 // } catch (err) {
 // // https://discuss.elastic.co/t/elasticsearch-503-ok-false-message-the-requested-deployment-is-currently-unavailable/200583
 // if (err.message.includes(`requested resource is currently unavailable`)) console.log(`Elasticsearch is unavailable, skipping, but not aborting`)
 // else throw err
 // }
 }
}

function getColumns (objs) {
 return Object.keys(objs[0]).map((key) => `"${key}"`).join(`, `)
}

function getValues (objs) {
 return objs.map(objPg => Object.values(objPg).map((value) => {
 // escape strings to prevent SQL injection
 if (typeof value === `string`) return `'${value.replace(/'/g, `''`)}'`
 // convert to DB specific null
 if (typeof value === `undefined` || value === null) return `NULL`
 return value
 }).join(`, `)).join(`), (`)
}

export function parseEnvFromInput (input) {
 const env = {}
 for (const key in input) {
 if (key === key.toUpperCase()) env[key] = input[key]
 }
 console.log(`[parseEnvFromInput] ${JSON.stringify(env)}`)
 Object.assign(process.env, env)
}

FDF Bike Shop (fdfbikeshop.cz) scraper

Output example

Industries

Where next?