traxxx/assets/js/releases/actions.js

import { graphql } from '../api';
import { releasesFragment, releaseFragment, releaseFields } from '../fragments';
import { curateRelease } from '../curate';
import getDateRange from '../get-date-range';

function initReleasesActions(store, router) {
	async function fetchReleases({ _commit }, { limit = 10, pageNumber = 1, range = 'latest' }) {
		const { before, after, orderBy } = getDateRange(range);

		const { connection: { releases, totalCount } } = await graphql(`
            query Releases(
                $limit:Int = 1000,
                $offset:Int = 0,
                $after:Datetime = "1900-01-01 00:00:00",
                $before:Datetime = "2100-01-01 00:00:00",
                $orderBy: [ReleasesOrderBy!],
                $exclude: [String!]
            ) {
                ${releasesFragment}
            }
        `, {
			limit,
			offset: Math.max(0, (pageNumber - 1)) * limit,
			after,
			before,
			orderBy,
			exclude: store.state.ui.filter,
		});

		return {
			releases: releases.map(release => curateRelease(release)),
			totalCount,
		};
	}

	async function fetchReleaseById({ _commit }, releaseId) {
		// const release = await get(`/releases/${releaseId}`);

		const { release } = await graphql(`
            query Release($releaseId:Int!) {
                ${releaseFragment}
            }
        `, {
			releaseId: Number(releaseId),
		});

		if (!release) {
			router.replace('/not-found');
			return null;
		}

		return curateRelease(release);
	}

	async function fetchMovies({ _commit }, { limit = 10, pageNumber = 1 }) {
		const { connection: { movies, totalCount } } = await graphql(`
            query Movies(
                $limit:Int = 1000,
                $offset:Int = 0,
            ) {
				connection: moviesConnection(
					first: $limit
					offset: $offset
					orderBy: DATE_DESC
				) {
					movies: nodes {
						id
						title
						url
						slug
						date
						datePrecision
						actors {
							id
							name
							slug
						}
						tags {
							id
							name
							slug
						}
						entity {
							id
							name
							slug
							type
							parent {
								id
								name
								slug
								type
							}
						}
						covers: moviesCovers {
							media {
								id
								path
								thumbnail
								lazy
							}
						}
					}
					totalCount
				}
			}
        `, {
			limit,
			offset: Math.max(0, (pageNumber - 1)) * limit,
		});

		return {
			movies: movies.map(release => curateRelease(release)),
			totalCount,
		};
	}

	async function fetchMovieById({ _commit }, movieId) {
		// const release = await get(`/releases/${releaseId}`);

		const { movie } = await graphql(`
			query Movie($movieId: Int!) {
				movie(id: $movieId) {
					id
					title
					slug
					url
					date
					actors {
						id
						name
						slug
						age
						ageFromBirth
						dateOfBirth
						birthCountry: countryByBirthCountryAlpha2 {
						  alpha2
						  name
						  alias
						}
						avatar: avatarMedia {
							id
							path
							thumbnail
							lazy
						}
					}
					covers: moviesCovers {
						media {
							id
							path
							thumbnail
							lazy
						}
					}
					trailer: moviesTrailerByMovieId {
						media {
							id
							path
						}
					}
					scenes: moviesScenes {
						scene {
							${releaseFields}
						}
					}
					tags {
						id
						slug
						name
					}
					photos {
						id
						index
						path
						thumbnail
						lazy
						comment
						sfw: sfwMedia {
							id
							thumbnail
							lazy
							path
							comment
						}
					}
					entity {
						id
						name
						slug
						type
						parent {
							id
							name
							slug
							type
						}
					}
				}
			}
		`, {
			movieId: Number(movieId),
		});

		if (!movie) {
			router.replace('/not-found');
			return null;
		}

		return curateRelease(movie);
	}

	return {
		fetchReleases,
		fetchReleaseById,
		fetchMovies,
		fetchMovieById,
	};
}

export default initReleasesActions;