traxxx/assets/js/curate.js

import dayjs from 'dayjs';

function curateActor(actor, release) {
	if (!actor) {
		return null;
	}

	const curatedActor = {
		...actor,
		height: actor.heightMetric && {
			metric: actor.heightMetric,
			imperial: actor.heightImperial,
		},
		weight: actor.weightMetric && {
			metric: actor.weightMetric,
			imperial: actor.weightImperial,
		},
		origin: actor.birthCountry && {
			city: actor.birthCity,
			state: actor.birthState,
			country: actor.birthCountry,
		},
		residence: actor.residenceCountry && {
			city: actor.residenceCity,
			state: actor.residenceState,
			country: actor.residenceCountry,
		},
		scrapedAt: new Date(actor.createdAt),
		updatedAt: new Date(actor.updatedAt),
	};

	if (actor.profiles) {
		const photos = actor.profiles
			.map(profile => ({ entity: profile.entity, ...profile.avatar }))
			.filter(avatar => avatar.id && (!curatedActor.avatar || avatar.hash !== curatedActor.avatar.hash));

		const descriptions = actor.profiles.reduce((acc, profile) => ({
			...acc,
			...(profile.description && {
				[profile.descriptionHash]: {
					text: profile.description,
					entity: profile.entity,
				},
			}),
		}), {});

		curatedActor.photos = Object.values(photos.reduce((acc, photo) => ({ ...acc, [photo.hash]: photo }), {}));
		curatedActor.descriptions = Object.values(descriptions);
	}

	if (release && release.date && curatedActor.birthdate) {
		curatedActor.ageThen = dayjs(release.date).diff(actor.birthdate, 'year');
	}

	if (actor.aliasFor) {
		curatedActor.aliasFor = curateActor(curatedActor.aliasFor);
	}

	curatedActor.stashes = actor.stashes?.map(stash => stash.stash || stash) || [];

	return curatedActor;
}

function curateRelease(release) {
	const curatedRelease = {
		...release,
		actors: [],
		poster: release.poster && release.poster.media,
		tags: release.tags ? release.tags.map(tag => tag.tag || tag) : [],
	};

	if (release.scenes) curatedRelease.scenes = release.scenes.filter(Boolean).map(({ scene }) => curateRelease(scene));
	if (release.movies) curatedRelease.movies = release.movies.filter(Boolean).map(({ movie }) => curateRelease(movie));
	if (release.chapters) curatedRelease.chapters = release.chapters.filter(Boolean).map(chapter => curateRelease(chapter));
	if (release.photos) curatedRelease.photos = release.photos.filter(Boolean).map(photo => photo.media || photo);
	if (release.covers) curatedRelease.covers = release.covers.filter(Boolean).map(({ media }) => media);
	if (release.trailer) curatedRelease.trailer = release.trailer.media;
	if (release.teaser) curatedRelease.teaser = release.teaser.media;
	if (release.actors) curatedRelease.actors = release.actors.filter(Boolean).map(actor => curateActor(actor.actor || actor, curatedRelease));
	if (release.directors) curatedRelease.directors = release.directors.filter(Boolean).map(director => curateActor(director.director || director, curatedRelease));
	if (release.movieTags && release.movieTags.length > 0) curatedRelease.tags = release.movieTags.filter(Boolean).map(({ tag }) => tag);
	if (release.movieActors && release.movieActors.length > 0) curatedRelease.actors = release.movieActors.filter(Boolean).map(({ actor }) => curateActor(actor, curatedRelease));

	if (release.productionLocation) {
		curatedRelease.productionLocation = {
			raw: release.productionLocation,
			city: release.productionCity,
			state: release.productionState,
			country: release.productionCountry,
		};
	}

	return curatedRelease;
}

function curateEntity(entity, parent, releases) {
	const curatedEntity = {
		...entity,
		children: [],
	};

	if (entity.tags) curatedEntity.tags = entity.tags.map(({ tag }) => tag);

	if (entity.children) {
		if (entity.children.nodes) {
			curatedEntity.children = entity.children.nodes.map(childEntity => curateEntity(childEntity, curatedEntity));
		}

		curatedEntity.childrenTotal = entity.children.totalCount;
	}

	if (entity.parent || parent) curatedEntity.parent = curateEntity(entity.parent || parent);
	if (releases) curatedEntity.releases = releases.map(release => curateRelease(release));

	return curatedEntity;
}

function curateTag(tag) {
	const curatedTag = {
		...tag,
	};

	if (tag.releases) curatedTag.releases = tag.releases.map(({ release }) => curateRelease(release));
	if (tag.photos) curatedTag.photos = tag.photos.map(({ media }) => media);
	if (tag.poster) curatedTag.poster = tag.poster.media;

	return curatedTag;
}

function curateStash(stash) {
	const curatedStash = stash;

	if (stash.scenes) {
		curatedStash.scenes = stash.scenes.map(item => ({
			...item,
			scene: curateRelease(item.scene),
		}));
	}

	if (stash.actors) {
		curatedStash.actors = stash.actors.map(item => ({
			...item,
			actor: curateActor(item.actor),
		}));
	}

	return curatedStash;
}

function curateUser(user) {
	const curatedUser = user;

	if (user.stashes) {
		curatedUser.stashes = user.stashes.map(stash => curateStash(stash));
	}

	return curatedUser;
}

export {
	curateActor,
	curateEntity,
	curateRelease,
	curateTag,
	curateStash,
	curateUser,
};