524 lines
14 KiB
JavaScript
524 lines
14 KiB
JavaScript
import config from 'config';
|
|
import { differenceInYears } from 'date-fns';
|
|
import { unit } from 'mathjs';
|
|
|
|
import { knexOwner as knex, knexManticore } from './knex.js';
|
|
import { utilsApi } from './manticore.js';
|
|
import { HttpError } from './errors.js';
|
|
import { fetchCountriesByAlpha2 } from './countries.js';
|
|
import { curateStash } from './stashes.js';
|
|
import escape from '../utils/escape-manticore.js';
|
|
import slugify from '../utils/slugify.js';
|
|
|
|
export function curateActor(actor, context = {}) {
|
|
return {
|
|
id: actor.id,
|
|
slug: actor.slug,
|
|
name: actor.name,
|
|
gender: actor.gender,
|
|
age: actor.age,
|
|
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),
|
|
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())),
|
|
},
|
|
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: actor.birth_country_alpha2 && {
|
|
country: actor.birth_country_alpha2 && {
|
|
alpha2: actor.birth_country_alpha2,
|
|
name: actor.birth_country_name,
|
|
},
|
|
},
|
|
residence: actor.residence_country_alpha2 && {
|
|
country: actor.residence_country_alpha2 && {
|
|
alpha2: actor.residence_country_alpha2,
|
|
name: actor.residence_country_name,
|
|
},
|
|
},
|
|
avatar: actor.avatar && {
|
|
id: actor.avatar.id,
|
|
path: actor.avatar.path,
|
|
thumbnail: actor.avatar.thumbnail,
|
|
lazy: actor.avatar.lazy,
|
|
isS3: actor.avatar.is_s3,
|
|
},
|
|
createdAt: actor.created_at,
|
|
updatedAt: actor.updated_at,
|
|
likes: actor.stashed,
|
|
stashes: context.stashes?.map((stash) => curateStash(stash)) || [],
|
|
...context.append?.[actor.id],
|
|
};
|
|
}
|
|
|
|
export function sortActorsByGender(actors, context = {}) {
|
|
if (!actors) {
|
|
return actors;
|
|
}
|
|
|
|
const alphaActors = actors.sort((actorA, actorB) => actorA.name.localeCompare(actorB.name, 'en'));
|
|
const genderActors = ['transsexual', 'female', undefined, null, 'male'].flatMap((gender) => alphaActors.filter((actor) => actor.gender === gender));
|
|
|
|
const titleSlug = slugify(context.title);
|
|
const titleActors = titleSlug ? genderActors.sort((actorA, actorB) => {
|
|
const actorASlug = actorA.slug.split('-')[0];
|
|
const actorBSlug = actorB.slug.split('-')[0];
|
|
|
|
if (titleSlug.includes(actorASlug) && !titleSlug.includes(actorBSlug)) {
|
|
return -1;
|
|
}
|
|
|
|
if (titleSlug.includes(actorBSlug) && !titleSlug.includes(actorASlug)) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}) : alphaActors;
|
|
|
|
return titleActors;
|
|
}
|
|
|
|
export async function fetchActorsById(actorIds, options = {}, reqUser) {
|
|
const [actors, stashes] = await Promise.all([
|
|
knex('actors')
|
|
.select(
|
|
'actors.*',
|
|
'actors_meta.*',
|
|
'birth_countries.alpha2 as birth_country_alpha2',
|
|
knex.raw('COALESCE(birth_countries.alias, birth_countries.name) as birth_country_name'),
|
|
'residence_countries.alpha2 as residence_country_alpha2',
|
|
knex.raw('COALESCE(residence_countries.alias, residence_countries.name) as residence_country_name'),
|
|
)
|
|
.leftJoin('actors_meta', 'actors_meta.actor_id', 'actors.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')
|
|
.whereIn('actors.id', actorIds)
|
|
.modify((builder) => {
|
|
if (options.order) {
|
|
builder.orderBy(...options.order);
|
|
}
|
|
}),
|
|
reqUser
|
|
? knex('stashes_actors')
|
|
.leftJoin('stashes', 'stashes.id', 'stashes_actors.stash_id')
|
|
.where('stashes.user_id', reqUser.id)
|
|
.whereIn('stashes_actors.actor_id', actorIds)
|
|
: [],
|
|
]);
|
|
|
|
if (options.order) {
|
|
return actors.map((actorEntry) => curateActor(actorEntry, {
|
|
stashes: stashes.filter((stash) => stash.actor_id === actorEntry.id),
|
|
append: options.append,
|
|
}));
|
|
}
|
|
|
|
const curatedActors = actorIds.map((actorId) => {
|
|
const actor = actors.find((actorEntry) => actorEntry.id === actorId);
|
|
|
|
if (!actor) {
|
|
console.warn(`Can't match actor ${actorId}`);
|
|
return null;
|
|
}
|
|
|
|
return curateActor(actor, {
|
|
stashes: stashes.filter((stash) => stash.actor_id === actor.id),
|
|
append: options.append,
|
|
});
|
|
}).filter(Boolean);
|
|
|
|
return curatedActors;
|
|
}
|
|
|
|
function curateOptions(options) {
|
|
if (options?.limit > 120) {
|
|
throw new HttpError('Limit must be <= 120', 400);
|
|
}
|
|
|
|
return {
|
|
page: options?.page || 1,
|
|
limit: options?.limit || 30,
|
|
requireAvatar: options?.requireAvatar || false,
|
|
order: [escape(options.order?.[0]) || 'name', escape(options.order?.[1]) || 'asc'],
|
|
};
|
|
}
|
|
|
|
/*
|
|
const sortMap = {
|
|
likes: 'stashed',
|
|
scenes: 'scenes',
|
|
relevance: '_score',
|
|
};
|
|
|
|
function getSort(order) {
|
|
if (order[0] === 'name') {
|
|
return [{
|
|
slug: order[1],
|
|
}];
|
|
}
|
|
|
|
return [
|
|
{
|
|
[sortMap[order[0]]]: order[1],
|
|
},
|
|
{
|
|
slug: 'asc', // sort by name where primary order is equal
|
|
},
|
|
];
|
|
}
|
|
|
|
function buildQuery(filters) {
|
|
const query = {
|
|
bool: {
|
|
must: [],
|
|
},
|
|
};
|
|
|
|
const expressions = {
|
|
age: 'if(date_of_birth, floor((now() - date_of_birth) / 31556952), 0)',
|
|
};
|
|
|
|
if (filters.query) {
|
|
query.bool.must.push({
|
|
match: {
|
|
name: filters.query,
|
|
},
|
|
});
|
|
}
|
|
|
|
['gender', 'country'].forEach((attribute) => {
|
|
if (filters[attribute]) {
|
|
query.bool.must.push({
|
|
equals: {
|
|
[attribute]: filters[attribute],
|
|
},
|
|
});
|
|
}
|
|
});
|
|
|
|
['age', 'height', 'weight'].forEach((attribute) => {
|
|
if (filters[attribute]) {
|
|
query.bool.must.push({
|
|
range: {
|
|
[attribute]: {
|
|
gte: filters[attribute][0],
|
|
lte: filters[attribute][1],
|
|
},
|
|
},
|
|
});
|
|
}
|
|
});
|
|
|
|
if (filters.dateOfBirth && filters.dobType === 'dateOfBirth') {
|
|
query.bool.must.push({
|
|
equals: {
|
|
date_of_birth: Math.floor(filters.dateOfBirth.getTime() / 1000),
|
|
},
|
|
});
|
|
}
|
|
|
|
if (filters.dateOfBirth && filters.dobType === 'birthday') {
|
|
expressions.month_of_birth = 'month(date_of_birth)';
|
|
expressions.day_of_birth = 'day(date_of_birth)';
|
|
|
|
const month = filters.dateOfBirth.getMonth() + 1;
|
|
const day = filters.dateOfBirth.getDate();
|
|
|
|
query.bool.must.push({
|
|
bool: {
|
|
must: [
|
|
{
|
|
equals: {
|
|
month_of_birth: month,
|
|
},
|
|
},
|
|
{
|
|
equals: {
|
|
day_of_birth: day,
|
|
},
|
|
},
|
|
],
|
|
},
|
|
});
|
|
}
|
|
|
|
if (filters.cup) {
|
|
expressions.cup_in_range = `regex(cup, '^[${filters.cup[0]}-${filters.cup[1]}]')`;
|
|
|
|
query.bool.must.push({
|
|
equals: {
|
|
cup_in_range: 1,
|
|
},
|
|
});
|
|
}
|
|
|
|
if (typeof filters.naturalBoobs === 'boolean') {
|
|
query.bool.must.push({
|
|
equals: {
|
|
natural_boobs: filters.naturalBoobs ? 2 : 1, // manticore boolean does not support null, so 0 = null, 1 = false (enhanced), 2 = true (natural)
|
|
},
|
|
});
|
|
}
|
|
|
|
if (filters.requireAvatar) {
|
|
query.bool.must.push({
|
|
equals: {
|
|
has_avatar: 1,
|
|
},
|
|
});
|
|
}
|
|
|
|
return { query, expressions };
|
|
}
|
|
|
|
async function queryManticoreJson(filters, options) {
|
|
const { query, expressions } = buildQuery(filters);
|
|
|
|
const result = await searchApi.search({
|
|
index: 'actors',
|
|
query,
|
|
expressions,
|
|
limit: options.limit,
|
|
offset: (options.page - 1) * options.limit,
|
|
sort: getSort(options.order, filters),
|
|
aggs: {
|
|
countries: {
|
|
terms: {
|
|
field: 'country',
|
|
size: 300,
|
|
},
|
|
sort: [{ country: { order: 'asc' } }],
|
|
},
|
|
},
|
|
options: {
|
|
max_matches: config.database.manticore.maxMatches,
|
|
max_query_time: config.database.manticore.maxQueryTime,
|
|
},
|
|
});
|
|
|
|
const actors = result.hits.hits.map((hit) => ({
|
|
id: hit._id,
|
|
...hit._source,
|
|
_score: hit._score,
|
|
}));
|
|
|
|
return {
|
|
actors,
|
|
total: result.hits.total,
|
|
aggregations: result.aggregations && Object.fromEntries(Object.entries(result.aggregations).map(([key, { buckets }]) => [key, buckets])),
|
|
};
|
|
}
|
|
*/
|
|
|
|
async function queryManticoreSql(filters, options, _reqUser) {
|
|
const aggSize = config.database.manticore.maxAggregateSize;
|
|
|
|
const sqlQuery = knexManticore.raw(`
|
|
:query:
|
|
OPTION
|
|
max_matches=:maxMatches:,
|
|
max_query_time=:maxQueryTime:
|
|
:countriesFacet:;
|
|
show meta;
|
|
`, {
|
|
query: knexManticore(filters.stashId ? 'actors_stashed' : 'actors')
|
|
.modify((builder) => {
|
|
if (filters.stashId) {
|
|
builder.select(knex.raw(`
|
|
actors.id as id,
|
|
actors.slug,
|
|
actors.gender as gender,
|
|
actors.country as country,
|
|
actors.height as height,
|
|
actors.mass as mass,
|
|
actors.cup as cup,
|
|
actors.natural_boobs as natural_boobs,
|
|
actors.date_of_birth as date_of_birth,
|
|
actors.has_avatar as has_avatar,
|
|
actors.scenes as scenes,
|
|
actors.stashed as stashed,
|
|
created_at as stashed_at,
|
|
if(actors.date_of_birth, floor((now() - actors.date_of_birth) / 31556952), 0) as age,
|
|
weight() as _score
|
|
`));
|
|
|
|
builder
|
|
.innerJoin('actors', 'actors.id', 'actors_stashed.actor_id')
|
|
.where('stash_id', filters.stashId);
|
|
} else {
|
|
builder.select(knex.raw('*, weight() as _score'));
|
|
}
|
|
|
|
if (filters.query) {
|
|
builder.whereRaw('match(\'@name :query:\', actors)', { query: escape(filters.query) });
|
|
}
|
|
|
|
// attribute filters
|
|
['country'].forEach((attribute) => {
|
|
if (filters[attribute]) {
|
|
builder.where(attribute, filters[attribute]);
|
|
}
|
|
});
|
|
|
|
if (filters.gender === 'other') {
|
|
builder.whereNull('gender');
|
|
} else if (filters.gender) {
|
|
builder.where('gender', filters.gender);
|
|
}
|
|
|
|
if (filters.age) {
|
|
builder.select('if(date_of_birth, floor((now() - date_of_birth) / 31556952), 0) as age');
|
|
}
|
|
|
|
// range filters
|
|
['age', 'height'].forEach((attribute) => {
|
|
if (filters[attribute]) {
|
|
builder
|
|
.where(attribute, '>=', filters[attribute][0])
|
|
.where(attribute, '<=', filters[attribute][1]);
|
|
}
|
|
});
|
|
|
|
if (filters.weight) {
|
|
// weight is a reserved keyword in manticore
|
|
builder
|
|
.where('mass', '>=', filters.weight[0])
|
|
.where('mass', '<=', filters.weight[1]);
|
|
}
|
|
|
|
if (filters.dateOfBirth && filters.dobType === 'dateOfBirth') {
|
|
builder.where('date_of_birth', Math.floor(filters.dateOfBirth.getTime() / 1000));
|
|
}
|
|
|
|
if (filters.dateOfBirth && filters.dobType === 'birthday') {
|
|
const month = filters.dateOfBirth.getMonth() + 1;
|
|
const day = filters.dateOfBirth.getDate();
|
|
|
|
builder.select('month(date_of_birth) as month_of_birth, day(date_of_birth) as day_of_birth');
|
|
|
|
builder
|
|
.where('month_of_birth', month)
|
|
.where('day_of_birth', day);
|
|
}
|
|
|
|
if (filters.cup) {
|
|
builder.select(`regex(actors.cup, '^[${filters.cup[0]}-${filters.cup[1]}]') as cup_in_range`);
|
|
builder.where('cup_in_range', 1);
|
|
}
|
|
|
|
if (typeof filters.naturalBoobs === 'boolean') {
|
|
builder.where('natural_boobs', filters.naturalBoobs ? 2 : 1); // manticore boolean does not support null, so 0 = null, 1 = false (enhanced), 2 = true (natural)
|
|
}
|
|
|
|
if (filters.requireAvatar) {
|
|
builder.where('has_avatar', 1);
|
|
}
|
|
|
|
if (options.order?.[0] === 'name') {
|
|
builder.orderBy('actors.slug', options.order[1]);
|
|
} else if (options.order?.[0] === 'likes') {
|
|
builder.orderBy([
|
|
{ column: 'actors.stashed', order: options.order[1] },
|
|
{ column: 'actors.slug', order: 'asc' },
|
|
]);
|
|
} else if (options.order?.[0] === 'scenes') {
|
|
builder.orderBy([
|
|
{ column: 'actors.scenes', order: options.order[1] },
|
|
{ column: 'actors.slug', order: 'asc' },
|
|
]);
|
|
} else if (options.order?.[0] === 'results') {
|
|
builder.orderBy([
|
|
{ column: '_score', order: options.order[1] },
|
|
{ column: 'actors.slug', order: 'asc' },
|
|
]);
|
|
} else if (options.order?.[0] === 'stashed' && filters.stashId) {
|
|
builder.orderBy([
|
|
{ column: 'stashed_at', order: options.order[1] },
|
|
{ column: 'actors.slug', order: 'asc' },
|
|
]);
|
|
} else if (options.order) {
|
|
builder.orderBy([
|
|
{ column: `actors.${options.order[0]}`, order: options.order[1] },
|
|
{ column: 'actors.slug', order: 'asc' },
|
|
]);
|
|
} else {
|
|
builder.orderBy('actors.slug', 'asc');
|
|
}
|
|
})
|
|
.limit(options.limit)
|
|
.offset((options.page - 1) * options.limit)
|
|
.toString(),
|
|
// option threads=1 fixes actors, but drastically slows down performance, wait for fix
|
|
countriesFacet: options.aggregateActors ? knex.raw('facet actors.country order by count(*) desc limit 300', [aggSize]) : null,
|
|
maxMatches: config.database.manticore.maxMatches,
|
|
maxQueryTime: config.database.manticore.maxQueryTime,
|
|
}).toString();
|
|
|
|
// manticore does not seem to accept table.column syntax if 'table' is primary (yet?), crude work-around
|
|
const curatedSqlQuery = filters.stashId
|
|
? sqlQuery
|
|
: sqlQuery.replace(/actors\./g, '');
|
|
|
|
if (process.env.NODE_ENV === 'development') {
|
|
console.log(curatedSqlQuery);
|
|
}
|
|
|
|
const results = await utilsApi.sql(curatedSqlQuery);
|
|
|
|
// console.log(results[0]);
|
|
|
|
const countries = results
|
|
.find((result) => (result.columns[0].actor_ids || result.columns[0]['scenes.country']) && result.columns[1]['count(*)'])
|
|
?.data.map((row) => ({ key: row.actor_ids || row['scenes.country'], doc_count: row['count(*)'] }))
|
|
|| [];
|
|
|
|
const total = Number(results.at(-1).data.find((entry) => entry.Variable_name === 'total_found').Value);
|
|
|
|
return {
|
|
actors: results[0].data,
|
|
total,
|
|
aggregations: {
|
|
countries,
|
|
},
|
|
};
|
|
}
|
|
|
|
export async function fetchActors(filters, rawOptions, reqUser) {
|
|
const options = curateOptions(rawOptions);
|
|
|
|
console.log('filters', filters);
|
|
console.log('options', options);
|
|
|
|
const result = await queryManticoreSql(filters, options, reqUser);
|
|
|
|
// console.log('result', result);
|
|
|
|
const actorIds = result.actors.map((actor) => Number(actor.id));
|
|
const [actors, countries] = await Promise.all([
|
|
fetchActorsById(actorIds, {}, reqUser),
|
|
fetchCountriesByAlpha2(result.aggregations.countries.map((bucket) => bucket.key)),
|
|
]);
|
|
|
|
return {
|
|
actors,
|
|
countries,
|
|
total: result.total,
|
|
limit: options.limit,
|
|
};
|
|
}
|