Integrated channel filter, partially restored actor bio.

src/actors.js

@@ -1,4 +1,5 @@
 import { differenceInYears } from 'date-fns';
+import { unit } from 'mathjs';
 
 import knex from './knex.js';
 import { searchApi } from './manticore.js';
@@ -15,13 +16,36 @@ export function curateActor(actor, context = {}) {
 		dateOfBirth: actor.date_of_birth,
 		ageFromBirth: actor.date_of_birth && differenceInYears(Date.now(), actor.date_of_birth),
 		ageThen: context.sceneDate && actor.date_of_birth && differenceInYears(context.sceneDate, actor.date_of_birth),
-		birthCountry: actor.birth_country_alpha2 && {
-			alpha2: actor.birth_country_alpha2,
-			name: actor.birth_country_name,
+		bust: actor.bust,
+		cup: actor.cup,
+		waist: actor.waist,
+		hip: actor.hip,
+		naturalBoobs: actor.naturalBoobs,
+		height: actor.height && {
+			metric: actor.height,
+			imperial: unit(actor.height, 'cm').splitUnit(['ft', 'in']).map((value) => Math.round(value.toNumber())),
 		},
-		residenceCountry: actor.residence_country_alpha2 && {
-			alpha2: actor.residence_country_alpha2,
-			name: actor.residence_country_name,
+		weight: actor.weight && {
+			metric: actor.weight,
+			imperial: Math.round(unit(actor.weight, 'kg').toNumeric('lbs')),
+		},
+		eyes: actor.eyes,
+		hairColor: actor.hairColor,
+		hasTattoos: actor.has_tattoos,
+		tattoos: actor.tattoos,
+		hasPiercings: actor.has_piercings,
+		piercings: actor.piercings,
+		origin: {
+			country: actor.birth_country_alpha2 && {
+				alpha2: actor.birth_country_alpha2,
+				name: actor.birth_country_name,
+			},
+		},
+		residence: {
+			country: actor.residence_country_alpha2 && {
+				alpha2: actor.residence_country_alpha2,
+				name: actor.residence_country_name,
+			},
 		},
 		avatar: actor.avatar && {
 			id: actor.avatar.id,
@@ -30,6 +54,8 @@ export function curateActor(actor, context = {}) {
 			lazy: actor.avatar.lazy,
 			isS3: actor.avatar.is_s3,
 		},
+		createdAt: actor.created_at,
+		updatedAt: actor.updated_at,
 		likes: actor.stashed,
 		...context.append?.[actor.id],
 	};
@@ -90,8 +116,6 @@ function curateOptions(options) {
 }
 
 function buildQuery(filters) {
-	console.log('filters', filters);
-
 	const query = {
 		bool: {
 			must: [],
@@ -103,8 +127,6 @@ function buildQuery(filters) {
 	};
 
 	if (filters.query) {
-		console.log(filters.query);
-
 		query.bool.must.push({
 			match: {
 				name: filters.query,
@@ -224,8 +246,6 @@ export async function fetchActors(filters, rawOptions) {
 	const options = curateOptions(rawOptions);
 	const { query, expressions } = buildQuery(filters);
 
-	console.log(options);
-
 	const result = await searchApi.search({
 		index: 'actors',
 		query,

src/format.js

@@ -1,19 +0,0 @@
-import { format } from 'date-fns';
-
-export function formatDuration(duration, forceHours) {
-	const hours = Math.floor(duration / 3600);
-	const minutes = Math.floor((duration % 3600) / 60);
-	const seconds = Math.floor(duration % 60);
-
-	const [formattedHours, formattedMinutes, formattedSeconds] = [hours, minutes, seconds].map((segment) => segment.toString().padStart(2, '0'));
-
-	if (duration >= 3600 || forceHours) {
-		return `${formattedHours}:${formattedMinutes}:${formattedSeconds}`;
-	}
-
-	return `${formattedMinutes}:${formattedSeconds}`;
-}
-
-export function formatDate(date, template) {
-	return format(date, template);
-}

src/scenes.js

@@ -80,25 +80,17 @@ export async function fetchScenesById(sceneIds) {
 			.groupBy('channels.id', 'networks.id'),
 		knex('releases_actors')
 			.select(
-				'actors.*',
+				'actors_meta.*',
 				'releases_actors.release_id',
-				'avatars.id as avatar_id',
-				'avatars.path as avatar_path',
-				'avatars.thumbnail as avatar_thumbnail',
-				'avatars.lazy as avatar_lazy',
-				'avatars.width as avatar_width',
-				'avatars.height as avatar_height',
-				'avatars.is_s3 as avatar_s3',
 				'birth_countries.alpha2 as birth_country_alpha2',
 				'birth_countries.name as birth_country_name',
 				'residence_countries.alpha2 as residence_country_alpha2',
 				'residence_countries.name as residence_country_name',
 			)
 			.whereIn('release_id', sceneIds)
-			.leftJoin('actors', 'actors.id', 'releases_actors.actor_id')
-			.leftJoin('media as avatars', 'avatars.id', 'actors.avatar_media_id')
-			.leftJoin('countries as birth_countries', 'birth_countries.alpha2', 'actors.birth_country_alpha2')
-			.leftJoin('countries as residence_countries', 'residence_countries.alpha2', 'actors.residence_country_alpha2'),
+			.leftJoin('actors_meta', 'actors_meta.id', 'releases_actors.actor_id')
+			.leftJoin('countries as birth_countries', 'birth_countries.alpha2', 'actors_meta.birth_country_alpha2')
+			.leftJoin('countries as residence_countries', 'residence_countries.alpha2', 'actors_meta.residence_country_alpha2'),
 		knex('releases_directors')
 			.whereIn('release_id', sceneIds)
 			.leftJoin('actors as directors', 'directors.id', 'releases_directors.director_id'),
@@ -191,23 +183,26 @@ function buildQuery(filters = {}) {
 		sort = [{ created_at: 'desc' }, { effective_date: 'asc' }];
 	}
 
-	if (filters.actorIds) {
-		filters.actorIds.forEach((actorId) => {
-			query.bool.must.push({
-				equals: {
-					'any(actor_ids)': actorId,
-				},
-			});
+	if (filters.tagIds) {
+		filters.tagIds.forEach((tagId) => {
+			query.bool.must.push({ equals: { 'any(tag_ids)': tagId } });
 		});
 	}
 
-	if (filters.tagIds) {
-		filters.tagIds.forEach((tagId) => {
-			query.bool.must.push({
-				equals: {
-					'any(tag_ids)': tagId,
-				},
-			});
+	if (filters.entityId) {
+		query.bool.must.push({
+			bool: {
+				should: [
+					{ equals: { channel_id: filters.entityId } },
+					{ equals: { network_id: filters.entityId } },
+				],
+			},
+		});
+	}
+
+	if (filters.actorIds) {
+		filters.actorIds.forEach((actorId) => {
+			query.bool.must.push({ equals: { 'any(actor_ids)': actorId } });
 		});
 	}
 
@@ -221,8 +216,6 @@ function buildQuery(filters = {}) {
 	],
 	*/
 
-	console.log(query.bool.must);
-
 	return { query, sort };
 }
 
@@ -272,9 +265,6 @@ export async function fetchScenes(filters, rawOptions) {
 	const options = curateOptions(rawOptions);
 	const { query, sort } = buildQuery(filters);
 
-	console.log('filters', filters);
-	console.log('options', options);
-
 	const result = await searchApi.search({
 		index: 'scenes',
 		query,

src/web/scenes.js

@@ -4,8 +4,8 @@ import { fetchScenes } from '../scenes.js';
 import { parseActorIdentifier } from '../query.js';
 import redis from '../redis.js';
 
-async function getTagIdsBySlug(tagSlugs) {
-	const tagIds = await Promise.all(tagSlugs.map(async (slug) => {
+async function getIdsBySlug(slugs, domain) {
+	const ids = await Promise.all(slugs.map(async (slug) => {
 		if (!slug) {
 			return null;
 		}
@@ -14,19 +14,20 @@ async function getTagIdsBySlug(tagSlugs) {
 			return Number(slug); // already an ID or missing
 		}
 
-		const tagId = await redis.hGet('traxxx:tags:id_by_slug', slug);
+		const id = await redis.hGet(`traxxx:${domain}:id_by_slug`, slug);
 
-		return Number(tagId);
+		return Number(id);
 	}));
 
-	return tagIds.filter(Boolean);
+	return ids.filter(Boolean);
 }
 
 export async function curateScenesQuery(query) {
 	return {
 		scope: query.scope || 'latest',
 		actorIds: [query.actorId, ...(query.actors?.split(',') || []).map((identifier) => parseActorIdentifier(identifier)?.id)].filter(Boolean),
-		tagIds: await getTagIdsBySlug([query.tagId, ...(query.tags?.split(',') || [])]),
+		tagIds: await getIdsBySlug([query.tagId, ...(query.tags?.split(',') || [])], 'tags'),
+		entityId: query.e ? await getIdsBySlug([query.e], 'entities').then(([id]) => id) : query.entityId,
 	};
 }