KevinMidboe/seasonedShows
1
0
Fork 0
Code Issues 20 Pull Requests 2 Packages Projects Releases 8 Wiki Activity

Compare commits

base: KevinMidboe:spotlight
Branches Tags
KevinMidboe:master KevinMidboe:feat/typescripted KevinMidboe:spotlight KevinMidboe:feat/cookie-authentication KevinMidboe:research/graphql KevinMidboe:renovate/configure KevinMidboe:logging
KevinMidboe:v1.1.1 KevinMidboe:1.1.0 KevinMidboe:1.0.6 KevinMidboe:v1.0.5 KevinMidboe:v1.0.4 KevinMidboe:v1.0.3 KevinMidboe:v1.0.2 KevinMidboe:v1.0.1 KevinMidboe:v1.0.0
..
compare: KevinMidboe:renovate/configure
Branches Tags
KevinMidboe:master KevinMidboe:feat/typescripted KevinMidboe:spotlight KevinMidboe:feat/cookie-authentication KevinMidboe:research/graphql KevinMidboe:renovate/configure KevinMidboe:logging
KevinMidboe:v1.1.1 KevinMidboe:1.1.0 KevinMidboe:1.0.6 KevinMidboe:v1.0.5 KevinMidboe:v1.0.4 KevinMidboe:v1.0.3 KevinMidboe:v1.0.2 KevinMidboe:v1.0.1 KevinMidboe:v1.0.0

1 Commits
spotlight ... renovate/c

Author SHA1 Message Date
Renovate Bot
e981b32f6b Add renovate.json 2019-07-13 04:53:32 +00:00
117 changed files with 2392 additions and 17947 deletions
Expand all files Collapse all files

10
.prettierrc
View File

@@ -1,10 +0,0 @@
{
"tabWidth": 2,
"useTabs": false,
"semi": true,
"singleQuote": false,
"bracketSpacing": true,
"arrowParens": "avoid",
"vueIndentScriptAndStyle": false,
"trailingComma": "none"
}

1263
.spectral.json
View File

File diff suppressed because it is too large Load Diff

38
.stoplight/custom-functions/oasDiscriminator.js
View File

@@ -1,38 +0,0 @@
function isObject(value) {
return value !== null && typeof value === 'object';
}
export const oasDiscriminator = (schema, _opts, { path }) => {
/**
* This function verifies:
*
* 1. The discriminator property name is defined at this schema.
* 2. The discriminator property is in the required property list.
*/
if (!isObject(schema)) return;
if (typeof schema.discriminator !== 'string') return;
const discriminatorName = schema.discriminator;
const results = [];
if (!isObject(schema.properties) || !Object.keys(schema.properties).some(k => k === discriminatorName)) {
results.push({
message: `The discriminator property must be defined in this schema.`,
path: [...path, 'properties'],
});
}
if (!Array.isArray(schema.required) || !schema.required.some(n => n === discriminatorName)) {
results.push({
message: `The discriminator property must be in the required property list.`,
path: [...path, 'required'],
});
}
return results;
};
export default oasDiscriminator;

4274
.stoplight/custom-functions/oasDocumentSchema.js
View File

File diff suppressed because it is too large Load Diff

228
.stoplight/custom-functions/oasExample.js
View File

@@ -1,228 +0,0 @@
import { isPlainObject, pointerToPath } from '@stoplight/json';
import { createRulesetFunction } from '@stoplight/spectral-core';
import { oas2, oas3_1, extractDraftVersion, oas3_0 } from '@stoplight/spectral-formats';
import { schema as schemaFn } from '@stoplight/spectral-functions';
import traverse from 'json-schema-traverse';
const MEDIA_VALIDATION_ITEMS = {
2: [
{
field: 'examples',
multiple: true,
keyed: false,
},
],
3: [
{
field: 'example',
multiple: false,
keyed: false,
},
{
field: 'examples',
multiple: true,
keyed: true,
},
],
};
const SCHEMA_VALIDATION_ITEMS = {
2: ['example', 'x-example', 'default'],
3: ['example', 'default'],
};
function isObject(value) {
return value !== null && typeof value === 'object';
}
function rewriteNullable(schema, errors) {
for (const error of errors) {
if (error.keyword !== 'type') continue;
const value = getSchemaProperty(schema, error.schemaPath);
if (isPlainObject(value) && value.nullable === true) {
error.message += ',null';
}
}
}
const visitOAS2 = schema => {
if (schema['x-nullable'] === true) {
schema.nullable = true;
delete schema['x-nullable'];
}
};
function getSchemaProperty(schema, schemaPath) {
const path = pointerToPath(schemaPath);
let value = schema;
for (const fragment of path.slice(0, -1)) {
if (!isPlainObject(value)) {
return;
}
value = value[fragment];
}
return value;
}
const oasSchema = createRulesetFunction(
{
input: null,
options: {
type: 'object',
properties: {
schema: {
type: 'object',
},
},
additionalProperties: false,
},
},
function oasSchema(targetVal, opts, context) {
const formats = context.document.formats;
let { schema } = opts;
let dialect = 'draft4';
let prepareResults;
if (!formats) {
dialect = 'auto';
} else if (formats.has(oas3_1)) {
if (isPlainObject(context.document.data) && typeof context.document.data.jsonSchemaDialect === 'string') {
dialect = extractDraftVersion(context.document.data.jsonSchemaDialect) ?? 'draft2020-12';
} else {
dialect = 'draft2020-12';
}
} else if (formats.has(oas3_0)) {
prepareResults = rewriteNullable.bind(null, schema);
} else if (formats.has(oas2)) {
const clonedSchema = JSON.parse(JSON.stringify(schema));
traverse(clonedSchema, visitOAS2);
schema = clonedSchema;
prepareResults = rewriteNullable.bind(null, clonedSchema);
}
return schemaFn(
targetVal,
{
...opts,
schema,
prepareResults,
dialect,
},
context,
);
},
);
function* getMediaValidationItems(items, targetVal, givenPath, oasVersion) {
for (const { field, keyed, multiple } of items) {
if (!(field in targetVal)) {
continue;
}
const value = targetVal[field];
if (multiple) {
if (!isObject(value)) continue;
for (const exampleKey of Object.keys(value)) {
const exampleValue = value[exampleKey];
if (oasVersion === 3 && keyed && (!isObject(exampleValue) || 'externalValue' in exampleValue)) {
// should be covered by oas3-examples-value-or-externalValue
continue;
}
const targetPath = [...givenPath, field, exampleKey];
if (keyed) {
targetPath.push('value');
}
yield {
value: keyed && isObject(exampleValue) ? exampleValue.value : exampleValue,
path: targetPath,
};
}
return;
} else {
return yield {
value,
path: [...givenPath, field],
};
}
}
}
function* getSchemaValidationItems(fields, targetVal, givenPath) {
for (const field of fields) {
if (!(field in targetVal)) {
continue;
}
yield {
value: targetVal[field],
path: [...givenPath, field],
};
}
}
export default createRulesetFunction(
{
input: {
type: 'object',
},
options: {
type: 'object',
properties: {
oasVersion: {
enum: ['2', '3'],
},
schemaField: {
type: 'string',
},
type: {
enum: ['media', 'schema'],
},
},
additionalProperties: false,
},
},
function oasExample(targetVal, opts, context) {
const formats = context.document.formats;
const schemaOpts = {
schema: opts.schemaField === '$' ? targetVal : targetVal[opts.schemaField],
};
let results = void 0;
let oasVersion = parseInt(opts.oasVersion);
const validationItems =
opts.type === 'schema'
? getSchemaValidationItems(SCHEMA_VALIDATION_ITEMS[oasVersion], targetVal, context.path)
: getMediaValidationItems(MEDIA_VALIDATION_ITEMS[oasVersion], targetVal, context.path, oasVersion);
if (formats?.has(oas2) && 'required' in schemaOpts.schema && typeof schemaOpts.schema.required === 'boolean') {
schemaOpts.schema = { ...schemaOpts.schema };
delete schemaOpts.schema.required;
}
for (const validationItem of validationItems) {
const result = oasSchema(validationItem.value, schemaOpts, {
...context,
path: validationItem.path,
});
if (Array.isArray(result)) {
if (results === void 0) results = [];
results.push(...result);
}
}
return results;
},
);

28
.stoplight/custom-functions/oasOpFormDataConsumeCheck.js
View File

@@ -1,28 +0,0 @@
function isObject(value) {
return value !== null && typeof value === 'object';
}
const validConsumeValue = /(application\/x-www-form-urlencoded|multipart\/form-data)/;
export const oasOpFormDataConsumeCheck = targetVal => {
if (!isObject(targetVal)) return;
const parameters = targetVal.parameters;
const consumes = targetVal.consumes;
if (!Array.isArray(parameters) || !Array.isArray(consumes)) {
return;
}
if (parameters.some(p => isObject(p) && p.in === 'formData') && !validConsumeValue.test(consumes?.join(','))) {
return [
{
message: 'Consumes must include urlencoded, multipart, or form-data media type when using formData parameter.',
},
];
}
return;
};
export default oasOpFormDataConsumeCheck;

76
.stoplight/custom-functions/oasOpIdUnique.js
View File

@@ -1,76 +0,0 @@
import { isPlainObject } from '@stoplight/json';
function isObject(value) {
return value !== null && typeof value === 'object';
}
const validOperationKeys = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
function* getAllOperations(paths) {
if (!isPlainObject(paths)) {
return;
}
const item = {
path: '',
operation: '',
value: null,
};
for (const path of Object.keys(paths)) {
const operations = paths[path];
if (!isPlainObject(operations)) {
continue;
}
item.path = path;
for (const operation of Object.keys(operations)) {
if (!isPlainObject(operations[operation]) || !validOperationKeys.includes(operation)) {
continue;
}
item.operation = operation;
item.value = operations[operation];
yield item;
}
}
}
export const oasOpIdUnique = targetVal => {
if (!isObject(targetVal) || !isObject(targetVal.paths)) return;
const results = [];
const { paths } = targetVal;
const seenIds = [];
for (const { path, operation } of getAllOperations(paths)) {
const pathValue = paths[path];
if (!isObject(pathValue)) continue;
const operationValue = pathValue[operation];
if (!isObject(operationValue) || !('operationId' in operationValue)) {
continue;
}
const { operationId } = operationValue;
if (seenIds.includes(operationId)) {
results.push({
message: 'operationId must be unique.',
path: ['paths', path, operation, 'operationId'],
});
} else {
seenIds.push(operationId);
}
}
return results;
};
export default oasOpIdUnique;

81
.stoplight/custom-functions/oasOpParams.js
View File

@@ -1,81 +0,0 @@
function isObject(value) {
return value !== null && typeof value === 'object';
}
function computeFingerprint(param) {
return `${String(param.in)}-${String(param.name)}`;
}
export const oasOpParams = (params, _opts, { path }) => {
/**
* This function verifies:
*
* 1. Operations must have unique `name` + `in` parameters.
* 2. Operation cannot have both `in:body` and `in:formData` parameters
* 3. Operation must have only one `in:body` parameter.
*/
if (!Array.isArray(params)) return;
if (params.length < 2) return;
const results = [];
const count = {
body: [],
formData: [],
};
const list = [];
const duplicates = [];
let index = -1;
for (const param of params) {
index++;
if (!isObject(param)) continue;
// skip params that are refs
if ('$ref' in param) continue;
// Operations must have unique `name` + `in` parameters.
const fingerprint = computeFingerprint(param);
if (list.includes(fingerprint)) {
duplicates.push(index);
} else {
list.push(fingerprint);
}
if (typeof param.in === 'string' && param.in in count) {
count[param.in].push(index);
}
}
if (duplicates.length > 0) {
for (const i of duplicates) {
results.push({
message: 'A parameter in this operation already exposes the same combination of "name" and "in" values.',
path: [...path, i],
});
}
}
if (count.body.length > 0 && count.formData.length > 0) {
results.push({
message: 'Operation must not have both "in:body" and "in:formData" parameters.',
});
}
if (count.body.length > 1) {
for (let i = 1; i < count.body.length; i++) {
results.push({
message: 'Operation must not have more than a single instance of the "in:body" parameter.',
path: [...path, count.body[i]],
});
}
}
return results;
};
export default oasOpParams;

141
.stoplight/custom-functions/oasOpSecurityDefined.js
View File

@@ -1,141 +0,0 @@
import { isPlainObject } from '@stoplight/json';
import { createRulesetFunction } from '@stoplight/spectral-core';
function isObject(value) {
return value !== null && typeof value === 'object';
}
const validOperationKeys = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
function* getAllOperations(paths) {
if (!isPlainObject(paths)) {
return;
}
const item = {
path: '',
operation: '',
value: null,
};
for (const path of Object.keys(paths)) {
const operations = paths[path];
if (!isPlainObject(operations)) {
continue;
}
item.path = path;
for (const operation of Object.keys(operations)) {
if (!isPlainObject(operations[operation]) || !validOperationKeys.includes(operation)) {
continue;
}
item.operation = operation;
item.value = operations[operation];
yield item;
}
}
}
function _get(value, path) {
for (const segment of path) {
if (!isObject(value)) {
break;
}
value = value[segment];
}
return value;
}
export default createRulesetFunction(
{
input: {
type: 'object',
properties: {
paths: {
type: 'object',
},
security: {
type: 'array',
},
},
},
options: {
type: 'object',
properties: {
schemesPath: {
type: 'array',
items: {
type: ['string', 'number'],
},
},
},
},
},
function oasOpSecurityDefined(targetVal, { schemesPath }) {
const { paths } = targetVal;
const results = [];
const schemes = _get(targetVal, schemesPath);
const allDefs = isObject(schemes) ? Object.keys(schemes) : [];
// Check global security requirements
const { security } = targetVal;
if (Array.isArray(security)) {
for (const [index, value] of security.entries()) {
if (!isObject(value)) {
continue;
}
const securityKeys = Object.keys(value);
for (const securityKey of securityKeys) {
if (!allDefs.includes(securityKey)) {
results.push({
message: `API "security" values must match a scheme defined in the "${schemesPath.join('.')}" object.`,
path: ['security', index, securityKey],
});
}
}
}
}
for (const { path, operation, value } of getAllOperations(paths)) {
if (!isObject(value)) continue;
const { security } = value;
if (!Array.isArray(security)) {
continue;
}
for (const [index, value] of security.entries()) {
if (!isObject(value)) {
continue;
}
const securityKeys = Object.keys(value);
for (const securityKey of securityKeys) {
if (!allDefs.includes(securityKey)) {
results.push({
message: `Operation "security" values must match a scheme defined in the "${schemesPath.join(
'.',
)}" object.`,
path: ['paths', path, operation, 'security', index, securityKey],
});
}
}
}
}
return results;
},
);

32
.stoplight/custom-functions/oasOpSuccessResponse.js
View File

@@ -1,32 +0,0 @@
import { createRulesetFunction } from '@stoplight/spectral-core';
import { oas3 } from '@stoplight/spectral-formats';
export const oasOpSuccessResponse = createRulesetFunction(
{
input: {
type: 'object',
},
options: null,
},
(input, opts, context) => {
const isOAS3X = context.document.formats?.has(oas3) === true;
for (const response of Object.keys(input)) {
if (isOAS3X && (response === '2XX' || response === '3XX')) {
return;
}
if (Number(response) >= 200 && Number(response) < 400) {
return;
}
}
return [
{
message: 'Operation must define at least a single 2xx or 3xx response',
},
];
},
);
export default oasOpSuccessResponse;

162
.stoplight/custom-functions/oasPathParam.js
View File

@@ -1,162 +0,0 @@
function isObject(value) {
return value !== null && typeof value === 'object';
}
const pathRegex = /(\{;?\??[a-zA-Z0-9_-]+\*?\})/g;
const isNamedPathParam = p => {
return p.in !== void 0 && p.in === 'path' && p.name !== void 0;
};
const isUnknownNamedPathParam = (p, path, results, seen) => {
if (!isNamedPathParam(p)) {
return false;
}
if (p.required !== true) {
results.push(generateResult(requiredMessage(p.name), path));
}
if (p.name in seen) {
results.push(generateResult(uniqueDefinitionMessage(p.name), path));
return false;
}
return true;
};
const ensureAllDefinedPathParamsAreUsedInPath = (path, params, expected, results) => {
for (const p of Object.keys(params)) {
if (!params[p]) {
continue;
}
if (!expected.includes(p)) {
const resPath = params[p];
results.push(generateResult(`Parameter "${p}" must be used in path "${path}".`, resPath));
}
}
};
const ensureAllExpectedParamsInPathAreDefined = (path, params, expected, operationPath, results) => {
for (const p of expected) {
if (!(p in params)) {
results.push(
generateResult(`Operation must define parameter "{${p}}" as expected by path "${path}".`, operationPath),
);
}
}
};
export const oasPathParam = targetVal => {
/**
* This rule verifies:
*
* 1. for every param referenced in the path string ie /users/{userId}, var must be defined in either
* path.parameters, or operation.parameters object
* 2. every path.parameters + operation.parameters property must be used in the path string
*/
if (!isObject(targetVal) || !isObject(targetVal.paths)) {
return;
}
const results = [];
// keep track of normalized paths for verifying paths are unique
const uniquePaths = {};
const validOperationKeys = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
for (const path of Object.keys(targetVal.paths)) {
const pathValue = targetVal.paths[path];
if (!isObject(pathValue)) continue;
// verify normalized paths are functionally unique (ie `/path/{one}` vs `/path/{two}` are
// different but equivalent within the context of OAS)
const normalized = path.replace(pathRegex, '%'); // '%' is used here since its invalid in paths
if (normalized in uniquePaths) {
results.push(
generateResult(`Paths "${String(uniquePaths[normalized])}" and "${path}" must not be equivalent.`, [
'paths',
path,
]),
);
} else {
uniquePaths[normalized] = path;
}
// find all templated path parameters
const pathElements = [];
let match;
while ((match = pathRegex.exec(path))) {
const p = match[0].replace(/[{}?*;]/g, '');
if (pathElements.includes(p)) {
results.push(generateResult(`Path "${path}" must not use parameter "{${p}}" multiple times.`, ['paths', path]));
} else {
pathElements.push(p);
}
}
// find parameters set within the top-level 'parameters' object
const topParams = {};
if (Array.isArray(pathValue.parameters)) {
for (const [i, value] of pathValue.parameters.entries()) {
if (!isObject(value)) continue;
const fullParameterPath = ['paths', path, 'parameters', i];
if (isUnknownNamedPathParam(value, fullParameterPath, results, topParams)) {
topParams[value.name] = fullParameterPath;
}
}
}
if (isObject(targetVal.paths[path])) {
// find parameters set within the operation's 'parameters' object
for (const op of Object.keys(pathValue)) {
const operationValue = pathValue[op];
if (!isObject(operationValue)) continue;
if (op === 'parameters' || !validOperationKeys.includes(op)) {
continue;
}
const operationParams = {};
const { parameters } = operationValue;
const operationPath = ['paths', path, op];
if (Array.isArray(parameters)) {
for (const [i, p] of parameters.entries()) {
if (!isObject(p)) continue;
const fullParameterPath = [...operationPath, 'parameters', i];
if (isUnknownNamedPathParam(p, fullParameterPath, results, operationParams)) {
operationParams[p.name] = fullParameterPath;
}
}
}
const definedParams = { ...topParams, ...operationParams };
ensureAllDefinedPathParamsAreUsedInPath(path, definedParams, pathElements, results);
ensureAllExpectedParamsInPathAreDefined(path, definedParams, pathElements, operationPath, results);
}
}
}
return results;
};
function generateResult(message, path) {
return {
message,
path,
};
}
const requiredMessage = name => `Path parameter "${name}" must have "required" property that is set to "true".`;
const uniqueDefinitionMessage = name => `Path parameter "${name}" must not be defined multiple times.`;
export default oasPathParam;

88
.stoplight/custom-functions/oasSchema.js
View File

@@ -1,88 +0,0 @@
import traverse from 'json-schema-traverse';
import { schema as schemaFn } from '@stoplight/spectral-functions';
import { createRulesetFunction } from '@stoplight/spectral-core';
import { oas2, oas3_1, extractDraftVersion, oas3_0 } from '@stoplight/spectral-formats';
import { isPlainObject, pointerToPath } from '@stoplight/json';
function rewriteNullable(schema, errors) {
for (const error of errors) {
if (error.keyword !== 'type') continue;
const value = getSchemaProperty(schema, error.schemaPath);
if (isPlainObject(value) && value.nullable === true) {
error.message += ',null';
}
}
}
export default createRulesetFunction(
{
input: null,
options: {
type: 'object',
properties: {
schema: {
type: 'object',
},
},
additionalProperties: false,
},
},
function oasSchema(targetVal, opts, context) {
const formats = context.document.formats;
let { schema } = opts;
let dialect = 'draft4';
let prepareResults;
if (!formats) {
dialect = 'auto';
} else if (formats.has(oas3_1)) {
if (isPlainObject(context.document.data) && typeof context.document.data.jsonSchemaDialect === 'string') {
dialect = extractDraftVersion(context.document.data.jsonSchemaDialect) ?? 'draft2020-12';
} else {
dialect = 'draft2020-12';
}
} else if (formats.has(oas3_0)) {
prepareResults = rewriteNullable.bind(null, schema);
} else if (formats.has(oas2)) {
const clonedSchema = JSON.parse(JSON.stringify(schema));
traverse(clonedSchema, visitOAS2);
schema = clonedSchema;
prepareResults = rewriteNullable.bind(null, clonedSchema);
}
return schemaFn(
targetVal,
{
...opts,
schema,
prepareResults,
dialect,
},
context,
);
},
);
const visitOAS2 = schema => {
if (schema['x-nullable'] === true) {
schema.nullable = true;
delete schema['x-nullable'];
}
};
function getSchemaProperty(schema, schemaPath) {
const path = pointerToPath(schemaPath);
let value = schema;
for (const fragment of path.slice(0, -1)) {
if (!isPlainObject(value)) {
return;
}
value = value[fragment];
}
return value;
}

81
.stoplight/custom-functions/oasTagDefined.js
View File

@@ -1,81 +0,0 @@
// This function will check an API doc to verify that any tag that appears on
// an operation is also present in the global tags array.
import { isPlainObject } from '@stoplight/json';
function isObject(value) {
return value !== null && typeof value === 'object';
}
const validOperationKeys = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
function* getAllOperations(paths) {
if (!isPlainObject(paths)) {
return;
}
const item = {
path: '',
operation: '',
value: null,
};
for (const path of Object.keys(paths)) {
const operations = paths[path];
if (!isPlainObject(operations)) {
continue;
}
item.path = path;
for (const operation of Object.keys(operations)) {
if (!isPlainObject(operations[operation]) || !validOperationKeys.includes(operation)) {
continue;
}
item.operation = operation;
item.value = operations[operation];
yield item;
}
}
}
export const oasTagDefined = targetVal => {
if (!isObject(targetVal)) return;
const results = [];
const globalTags = [];
if (Array.isArray(targetVal.tags)) {
for (const tag of targetVal.tags) {
if (isObject(tag) && typeof tag.name === 'string') {
globalTags.push(tag.name);
}
}
}
const { paths } = targetVal;
for (const { path, operation, value } of getAllOperations(paths)) {
if (!isObject(value)) continue;
const { tags } = value;
if (!Array.isArray(tags)) {
continue;
}
for (const [i, tag] of tags.entries()) {
if (!globalTags.includes(tag)) {
results.push({
message: 'Operation tags must be defined in global tags.',
path: ['paths', path, operation, 'tags', i],
});
}
}
}
return results;
};
export default oasTagDefined;

50
.stoplight/custom-functions/oasUnusedComponent.js
View File

@@ -1,50 +0,0 @@
import { unreferencedReusableObject } from '@stoplight/spectral-functions';
import { createRulesetFunction } from '@stoplight/spectral-core';
function isObject(value) {
return value !== null && typeof value === 'object';
}
export default createRulesetFunction(
{
input: {
type: 'object',
properties: {
components: {
type: 'object',
},
},
required: ['components'],
},
options: null,
},
function oasUnusedComponent(targetVal, opts, context) {
const results = [];
const componentTypes = [
'schemas',
'responses',
'parameters',
'examples',
'requestBodies',
'headers',
'links',
'callbacks',
];
for (const type of componentTypes) {
const value = targetVal.components[type];
if (!isObject(value)) continue;
const resultsForType = unreferencedReusableObject(
value,
{ reusableObjectsLocation: `#/components/${type}` },
context,
);
if (resultsForType !== void 0 && Array.isArray(resultsForType)) {
results.push(...resultsForType);
}
}
return results;
},
);

51
.stoplight/custom-functions/refSiblings.js
View File

@@ -1,51 +0,0 @@
function isObject(value) {
return value !== null && typeof value === 'object';
}
function getParentValue(document, path) {
if (path.length === 0) {
return null;
}
let piece = document;
for (let i = 0; i < path.length - 1; i += 1) {
if (!isObject(piece)) {
return null;
}
piece = piece[path[i]];
}
return piece;
}
const refSiblings = (targetVal, opts, { document, path }) => {
const value = getParentValue(document.data, path);
if (!isObject(value)) {
return;
}
const keys = Object.keys(value);
if (keys.length === 1) {
return;
}
const results = [];
const actualObjPath = path.slice(0, -1);
for (const key of keys) {
if (key === '$ref') {
continue;
}
results.push({
message: '$ref must not be placed next to any other properties',
path: [...actualObjPath, key],
});
}
return results;
};
export default refSiblings;

92
.stoplight/custom-functions/typedEnum.js
View File

@@ -1,92 +0,0 @@
import { oas2, oas3_0 } from '@stoplight/spectral-formats';
import { printValue } from '@stoplight/spectral-runtime';
import { createRulesetFunction } from '@stoplight/spectral-core';
function getDataType(input, checkForInteger) {
const type = typeof input;
switch (type) {
case 'string':
case 'boolean':
return type;
case 'number':
if (checkForInteger && Number.isInteger(input)) {
return 'integer';
}
return 'number';
case 'object':
if (input === null) {
return 'null';
}
return Array.isArray(input) ? 'array' : 'object';
default:
throw TypeError('Unknown input type');
}
}
function getTypes(input, formats) {
const { type } = input;
if (
(input.nullable === true && formats?.has(oas3_0) === true) ||
(input['x-nullable'] === true && formats?.has(oas2) === true)
) {
return Array.isArray(type) ? [...type, 'null'] : [type, 'null'];
}
return type;
}
export const typedEnum = createRulesetFunction(
{
input: {
type: 'object',
properties: {
enum: {
type: 'array',
},
type: {
oneOf: [
{
type: 'array',
items: {
type: 'string',
},
},
{
type: 'string',
},
],
},
},
required: ['enum', 'type'],
},
options: null,
},
function (input, opts, context) {
const { enum: enumValues } = input;
const type = getTypes(input, context.document.formats);
const checkForInteger = type === 'integer' || (Array.isArray(type) && type.includes('integer'));
let results;
enumValues.forEach((value, i) => {
const valueType = getDataType(value, checkForInteger);
if (valueType === type || (Array.isArray(type) && type.includes(valueType))) {
return;
}
results ??= [];
results.push({
message: `Enum value ${printValue(enumValues[i])} must be "${String(type)}".`,
path: [...context.path, 'enum', i],
});
});
return results;
},
);
export default typedEnum;

2868
.stoplight/styleguide.json
View File

File diff suppressed because one or more lines are too long

3
.travis.yml
View File

@@ -1,5 +1,5 @@
language: node_js
node_js: '11.9.0'
node_js: '8.7.0'
git:
submodules: true
script:
@@ -7,7 +7,6 @@ script:
- yarn coverage
before_install:
- cd seasoned_api
- cp conf/development.json.example conf/development.json
before_script:
- yarn
- curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter

4
README.md
View File

@@ -10,8 +10,8 @@
<img src="https://travis-ci.org/KevinMidboe/seasonedShows.svg?branch=master"
alt="Travis CI">
</a>
<a href="https://coveralls.io/github/KevinMidboe/seasonedShows?branch=api/v2">
<img src="https://coveralls.io/repos/github/KevinMidboe/seasonedShows/badge.svg?branch=api/v2" alt="">
<a href="https://coveralls.io/github/KevinMidboe/seasonedShows?branch=coverage">
<img src="https://coveralls.io/repos/github/KevinMidboe/seasonedShows/badge.svg?branch=coverage" alt="">
</a>
<a href="https://snyk.io/test/github/KevinMidboe/seasonedShows?targetFile=seasoned_api/package.json">
<img src="https://snyk.io/test/github/KevinMidboe/seasonedShows/badge.svg?targetFile=seasoned_api/package.json" alt="">

6
client/package.json
View File

@@ -12,7 +12,7 @@
},
"dependencies": {
"clean-webpack-plugin": "^0.1.17",
"css-loader": "^1.0.0",
"css-loader": "^0.28.4",
"html-webpack-plugin": "^2.28.0",
"path": "^0.12.7",
"react": "^15.6.1",
@@ -30,8 +30,8 @@
"redux-thunk": "^2.2.0",
"urijs": "^1.18.12",
"webfontloader": "^1.6.28",
"webpack": "^4.0.0",
"webpack-dev-server": "^3.1.11",
"webpack": "^3.5.5",
"webpack-dev-server": "^2.4.5",
"webpack-merge": "^4.1.0"
},
"devDependencies": {

439
reference/seasoned-api.yaml
View File

@@ -1,439 +0,0 @@
openapi: 3.1.0
x-stoplight:
id: lu1x37qqzll6m
info:
title: seasoned api
version: '1.0'
summary: Season your media library with the shows and movies that you and your friends want.
description: |
This is the backend api for [seasoned request] that allows for uesrs to request movies and shows by fetching movies from themoviedb api and checks them with your plex library to identify if a movie is already present or not. This api allows to search my query, get themoviedb movie lists like popular and now playing, all while checking if the item is already in your plex library. Your friends can create users to see what movies or shows they have requested and searched for.
The api also uses torrent_search to search for matching torrents and returns results from any site or service available from torrent_search. As a admin of the site you can query torrent_search and return a magnet link that can be added to a autoadd folder of your favorite torrent client.
servers:
- url: 'https://request.movie/api'
description: poduction
- url: 'https://localhost:31459'
description: localhost
paths:
/v2/movie/now_playing:
get:
summary: Your GET endpoint
tags: []
responses:
'200':
description: OK
content:
application/json:
schema:
type: object
properties:
results:
type: array
items:
type: object
properties:
id:
type: integer
title:
type: string
year:
type: integer
overview:
type: string
poster:
type: string
backdrop:
type: string
release_date:
type: string
rating:
type: number
type:
type: string
page:
type: integer
total_results:
type: integer
total_pages:
type: integer
x-examples:
example-1:
results:
- id: 616037
title: 'Thor: Love and Thunder'
year: 2022
overview: 'After his retirement is interrupted by Gorr the God Butcher, a galactic killer who seeks the extinction of the gods, Thor enlists the help of King Valkyrie, Korg, and ex-girlfriend Jane Foster, who now inexplicably wields Mjolnir as the Mighty Thor. Together they embark upon a harrowing cosmic adventure to uncover the mystery of the God Butcher’s vengeance and stop him before it’s too late.'
poster: /pIkRyD18kl4FhoCNQuWxWu5cBLM.jpg
backdrop: /p1F51Lvj3sMopG948F5HsBbl43C.jpg
release_date: '2022-07-06T00:00:00.000Z'
rating: 6.8
type: movie
- id: 507086
title: Jurassic World Dominion
year: 2022
overview: 'Four years after Isla Nublar was destroyed, dinosaurs now live—and hunt—alongside humans all over the world. This fragile balance will reshape the future and determine, once and for all, whether human beings are to remain the apex predators on a planet they now share with history’s most fearsome creatures.'
poster: /kAVRgw7GgK1CfYEJq8ME6EvRIgU.jpg
backdrop: /9eAn20y26wtB3aet7w9lHjuSgZ3.jpg
release_date: '2022-06-01T00:00:00.000Z'
rating: 7.1
type: movie
- id: 438148
title: 'Minions: The Rise of Gru'
year: 2022
overview: 'A fanboy of a supervillain supergroup known as the Vicious 6, Gru hatches a plan to become evil enough to join them, with the backup of his followers, the Minions.'
poster: /wKiOkZTN9lUUUNZLmtnwubZYONg.jpg
backdrop: /nmGWzTLMXy9x7mKd8NKPLmHtWGa.jpg
release_date: '2022-06-29T00:00:00.000Z'
rating: 7.8
type: movie
- id: 585511
title: Luck
year: 2022
overview: 'Suddenly finding herself in the never-before-seen Land of Luck, the unluckiest person in the world must unite with the magical creatures there to turn her luck around.'
poster: /1HOYvwGFioUFL58UVvDRG6beEDm.jpg
backdrop: /3VQj6m0I6gkuRaljmhNZl0XR3by.jpg
release_date: '2022-08-05T00:00:00.000Z'
rating: 8.1
type: movie
- id: 756999
title: The Black Phone
year: 2022
overview: 'Finney Blake, a shy but clever 13-year-old boy, is abducted by a sadistic killer and trapped in a soundproof basement where screaming is of little use. When a disconnected phone on the wall begins to ring, Finney discovers that he can hear the voices of the killer’s previous victims. And they are dead set on making sure that what happened to them doesn’t happen to Finney.'
poster: /lr11mCT85T1JanlgjMuhs9nMht4.jpg
backdrop: /jqVyOIz8jxH0NUlc0QUHmV0uOcn.jpg
release_date: '2022-06-22T00:00:00.000Z'
rating: 8
type: movie
- id: 610150
title: 'Dragon Ball Super: Super Hero'
year: 2022
overview: 'The Red Ribbon Army, an evil organization that was once destroyed by Goku in the past, has been reformed by a group of people who have created new and mightier Androids, Gamma 1 and Gamma 2, and seek vengeance against Goku and his family.'
poster: /rugyJdeoJm7cSJL1q4jBpTNbxyU.jpg
backdrop: /uR0FopHrAjDlG5q6PZB07a1JOva.jpg
release_date: '2022-06-11T00:00:00.000Z'
rating: 7.5
type: movie
- id: 760104
title: X
year: 2022
overview: 'In 1979, a group of young filmmakers set out to make an adult film in rural Texas, but when their reclusive, elderly hosts catch them in the act, the cast find themselves fighting for their lives.'
poster: /woTQx9Q4b8aO13jR9dsj8C9JESy.jpg
backdrop: /2oXQpm0wfOkIL0jBJABbL5AfMs6.jpg
release_date: '2022-03-17T00:00:00.000Z'
rating: 6.7
type: movie
- id: 718789
title: Lightyear
year: 2022
overview: Legendary Space Ranger Buzz Lightyear embarks on an intergalactic adventure alongside a group of ambitious recruits and his robot companion Sox.
poster: /ox4goZd956BxqJH6iLwhWPL9ct4.jpg
backdrop: /nW5fUbldp1DYf2uQ3zJTUdachOu.jpg
release_date: '2022-06-15T00:00:00.000Z'
rating: 7.3
type: movie
- id: 725201
title: The Gray Man
year: 2022
overview: 'When a shadowy CIA agent uncovers damning agency secrets, he''s hunted across the globe by a sociopathic rogue operative who''s put a bounty on his head.'
poster: /8cXbitsS6dWQ5gfMTZdorpAAzEH.jpg
backdrop: /27Mj3rFYP3xqFy7lnz17vEd8Ms.jpg
release_date: '2022-07-13T00:00:00.000Z'
rating: 7
type: movie
- id: 758724
title: The Cellar
year: 2022
overview: 'When Keira Woods'' daughter mysteriously vanishes in the cellar of their new house in the country, she soon discovers there is an ancient and powerful entity controlling their home that she will have to face or risk losing her family''s souls forever.'
poster: /rtfGeS5WMXA6PtikIYUmYTSbVdg.jpg
backdrop: /qViFGWCHaSmW4gP00RGh3xjMjsP.jpg
release_date: '2022-03-25T00:00:00.000Z'
rating: 6.6
type: movie
- id: 961484
title: Last Seen Alive
year: 2022
overview: 'After Will Spann''s wife suddenly vanishes at a gas station, his desperate search to find her leads him down a dark path that forces him to run from authorities and take the law into his own hands.'
poster: /qvqyDj34Uivokf4qIvK4bH0m0qF.jpg
backdrop: /ftGzl2GCyko61Qp161bQElN2Uzd.jpg
release_date: '2022-05-19T00:00:00.000Z'
rating: 6.6
type: movie
- id: 675353
title: Sonic the Hedgehog 2
year: 2022
overview: 'After settling in Green Hills, Sonic is eager to prove he has what it takes to be a true hero. His test comes when Dr. Robotnik returns, this time with a new partner, Knuckles, in search for an emerald that has the power to destroy civilizations. Sonic teams up with his own sidekick, Tails, and together they embark on a globe-trotting journey to find the emerald before it falls into the wrong hands.'
poster: /6DrHO1jr3qVrViUO6s6kFiAGM7.jpg
backdrop: /8wwXPG22aNMpPGuXnfm3galoxbI.jpg
release_date: '2022-03-30T00:00:00.000Z'
rating: 7.7
type: movie
- id: 924482
title: The Ledge
year: 2022
overview: 'A rock climbing adventure between two friends turns into a terrifying nightmare. After Kelly captures the murder of her best friend on camera, she becomes the next target of a tight-knit group of friends who will stop at nothing to destroy the evidence and anyone in their way. Desperate for her safety, she begins a treacherous climb up a mountain cliff and her survival instincts are put to the test when she becomes trapped with the killers just 20 feet away.'
poster: /dHKfsdNcEPw7YIWFPIhqiuWrSAb.jpg
backdrop: /jazlkwXfw4KdF6fVTRsolOvRCmu.jpg
release_date: '2022-02-18T00:00:00.000Z'
rating: 6.3
type: movie
- id: 698948
title: Thirteen Lives
year: 2022
overview: 'Based on the true nail-biting mission that captivated the world. Twelve boys and the coach of a Thai soccer team explore the Tham Luang cave when an unexpected rainstorm traps them in a chamber inside the mountain. Entombed behind a maze of flooded cave tunnels, they face impossible odds. A team of world-class divers navigate through miles of dangerous cave networks to discover that finding the boys is only the beginning.'
poster: /yi5KcJqFxy0D6yP8nCfcF8gJGg5.jpg
backdrop: /tHR34A5n0my4maACNdLpWGd6QYq.jpg
release_date: '2022-07-18T00:00:00.000Z'
rating: 8
type: movie
- id: 614934
title: Elvis
year: 2022
overview: 'The life story of Elvis Presley as seen through the complicated relationship with his enigmatic manager, Colonel Tom Parker.'
poster: /qBOKWqAFbveZ4ryjJJwbie6tXkQ.jpg
backdrop: /rLo9T9jEg67UZPq3midjLnTUYYi.jpg
release_date: '2022-06-22T00:00:00.000Z'
rating: 7.9
type: movie
- id: 639933
title: The Northman
year: 2022
overview: 'Prince Amleth is on the verge of becoming a man when his father is brutally murdered by his uncle, who kidnaps the boy''s mother. Two decades later, Amleth is now a Viking who''s on a mission to save his mother, kill his uncle and avenge his father.'
poster: /8p9zXB7M78nZpm215zHfqpknMeM.jpg
backdrop: /k2G4WqGiT60K9yJnPh4K6VLnl3A.jpg
release_date: '2022-04-07T00:00:00.000Z'
rating: 7.2
type: movie
- id: 894169
title: Vendetta
year: 2022
overview: 'When his daughter is murdered, William Duncan takes the law into his own hands, setting out on a quest for retribution. After killing the street thug responsible for her death, he finds himself in the middle of a war with the thug''s brother, father, and their gang, who are equally hell-bent on getting even. What ensues is a tense back-and-forth game of vengeance. By the end, William comes to find that the quest for revenge never has a winner.'
poster: /7InGE2Sux0o9WGbbn0bl7nZzqEc.jpg
backdrop: /33qGtN2GpGEb94pn25PDPeWQZLk.jpg
release_date: '2022-05-17T00:00:00.000Z'
rating: 6.5
type: movie
- id: 718930
title: Bullet Train
year: 2022
overview: 'Unlucky assassin Ladybug is determined to do his job peacefully after one too many gigs gone off the rails. Fate, however, may have other plans, as Ladybug''s latest mission puts him on a collision course with lethal adversaries from around the globe—all with connected, yet conflicting, objectives—on the world''s fastest train.'
poster: /rTgfp0ZuikSUK8HK8Jgn3PUqteH.jpg
backdrop: /C8FpZfTPEZDjngPlatiFsaDB4A.jpg
release_date: '2022-07-03T00:00:00.000Z'
rating: 7.4
type: movie
- id: 697799
title: WarHunt
year: 2022
overview: '1945. A U.S. military cargo plane loses control and violently crashes behind enemy lines in the middle of the German black forest. Major Johnson sends a squad of his bravest soldiers on a rescue mission to retrieve the top-secret material the plane was carrying, led by Sergeants Brewer and Walsh. They soon discover hanged Nazi soldiers and other dead bodies bearing ancient, magical symbols. Suddenly their compasses fail, their perceptions twist and straying from the group leads to profound horrors as they are attacked by a powerful, supernatural force.'
poster: /9HFFwZOTBB7IPFmn9E0MXdWave3.jpg
backdrop: /mTupUmnuwwAyA0CNqpwaZn5mqjk.jpg
release_date: '2022-01-21T00:00:00.000Z'
rating: 5.1
type: movie
- id: 818397
title: Memory
year: 2022
overview: 'Alex, an assassin-for-hire, finds that he''s become a target after he refuses to complete a job for a dangerous criminal organization. With the crime syndicate and FBI in hot pursuit, Alex has the skills to stay ahead, except for one thing: he is struggling with severe memory loss, affecting his every move. Alex must question his every action and whom he can ultimately trust.'
poster: /4Q1n3TwieoULnuaztu9aFjqHDTI.jpg
backdrop: /vjnLXptqdxnpNJer5fWgj2OIGhL.jpg
release_date: '2022-04-28T00:00:00.000Z'
rating: 7.3
type: movie
page: 1
total_results: 1241
total_pages: 63
operationId: get-v2-movie-now_playing
description: ''
security:
- authorization: []
'/users/{userId}':
parameters:
- schema:
type: integer
name: userId
in: path
required: true
description: Id of an existing user.
get:
summary: Get User Info by User ID
tags: []
responses:
'200':
description: User Found
content:
application/json:
schema:
$ref: '#/components/schemas/User'
examples:
Get User Alice Smith:
value:
id: 142
firstName: Alice
lastName: Smith
email: alice.smith@gmail.com
dateOfBirth: '1997-10-31'
emailVerified: true
signUpDate: '2019-08-24'
'404':
description: User Not Found
operationId: get-users-userId
description: Retrieve the information of the user with the matching user ID.
patch:
summary: Update User Information
operationId: patch-users-userId
responses:
'200':
description: User Updated
content:
application/json:
schema:
$ref: '#/components/schemas/User'
examples:
Updated User Rebecca Baker:
value:
id: 13
firstName: Rebecca
lastName: Baker
email: rebecca@gmail.com
dateOfBirth: '1985-10-02'
emailVerified: false
createDate: '2019-08-24'
'404':
description: User Not Found
'409':
description: Email Already Taken
description: Update the information of an existing user.
requestBody:
content:
application/json:
schema:
type: object
properties:
firstName:
type: string
lastName:
type: string
email:
type: string
description: 'If a new email is given, the user''s email verified property will be set to false.'
dateOfBirth:
type: string
examples:
Update First Name:
value:
firstName: Rebecca
Update Email:
value:
email: rebecca@gmail.com
Update Last Name & Date of Birth:
value:
lastName: Baker
dateOfBirth: '1985-10-02'
description: Patch user properties to update.
/user:
post:
summary: Create New User
operationId: post-user
responses:
'200':
description: User Created
content:
application/json:
schema:
$ref: '#/components/schemas/User'
examples:
New User Bob Fellow:
value:
id: 12
firstName: Bob
lastName: Fellow
email: bob.fellow@gmail.com
dateOfBirth: '1996-08-24'
emailVerified: false
createDate: '2020-11-18'
'400':
description: Missing Required Information
'409':
description: Email Already Taken
requestBody:
content:
application/json:
schema:
type: object
properties:
firstName:
type: string
lastName:
type: string
email:
type: string
dateOfBirth:
type: string
format: date
required:
- firstName
- lastName
- email
- dateOfBirth
examples:
Create User Bob Fellow:
value:
firstName: Bob
lastName: Fellow
email: bob.fellow@gmail.com
dateOfBirth: '1996-08-24'
description: Post the necessary fields for the API to create a new user.
description: Create a new user.
components:
schemas:
User:
title: User
type: object
description: ''
examples:
- id: 142
firstName: Alice
lastName: Smith
email: alice.smith@gmail.com
dateOfBirth: '1997-10-31'
emailVerified: true
signUpDate: '2019-08-24'
properties:
id:
type: integer
description: Unique identifier for the given user.
firstName:
type: string
lastName:
type: string
email:
type: string
format: email
dateOfBirth:
type: string
format: date
example: '1997-10-31'
emailVerified:
type: boolean
description: Set to true if the user's email has been verified.
createDate:
type: string
format: date
description: The date that the user was created.
required:
- id
- firstName
- lastName
- email
- emailVerified
securitySchemes:
authorization:
name: Authorization token
type: apiKey
in: header
description: |-
An authorization token is a token that you provide when making API calls. Include the token in a header parameter called Authorization.
Example: `Authorization: eyJhbGciOiJIUzI1NiIsInR5cCI`
security:
- authorization: []

5
renovate.json Normal file
View File

@@ -0,0 +1,5 @@
{
"extends": [
"config:base"
]
}

40
seasoned_api/conf/development.json.example
View File

@@ -1,26 +1,20 @@
{
"database": {
"host": "../shows.db"
},
"webserver": {
"port": 31459,
"origins": []
},
"tmdb": {
"apiKey": ""
},
"plex": {
"ip": ""
},
"tautulli": {
"apiKey": "",
"ip": "",
"port": ""
},
"raven": {
"DSN": ""
},
"authentication": {
"database": {
"host": "../shows.db"
},
"webserver": {
"port": 31459
},
"tmdb": {
"apiKey": ""
},
"plex": {
"ip": ""
},
"raven": {
"DSN": ""
},
"authentication": {
"secret": "secret"
}
}
}

40
seasoned_api/package.json
View File

@@ -7,51 +7,39 @@
},
"main": "webserver/server.js",
"scripts": {
"start": "cross-env SEASONED_CONFIG=conf/development.json NODE_ENV=production NODE_PATH=. babel-node src/webserver/server.js",
"test": "cross-env SEASONED_CONFIG=conf/test.json NODE_PATH=. mocha --require @babel/register --recursive test/unit test/system",
"coverage": "cross-env SEASONED_CONFIG=conf/test.json NODE_PATH=. nyc mocha --require @babel/register --recursive test && nyc report --reporter=text-lcov | coveralls",
"start": "cross-env SEASONED_CONFIG=conf/development.json PROD=true NODE_PATH=. node src/webserver/server.js",
"test": "cross-env SEASONED_CONFIG=conf/test.json NODE_PATH=. mocha --recursive test/unit test/system",
"coverage": "cross-env SEASONED_CONFIG=conf/test.json NODE_PATH=. nyc mocha --recursive test && nyc report --reporter=text-lcov | coveralls",
"lint": "./node_modules/.bin/eslint src/",
"update": "cross-env SEASONED_CONFIG=conf/development.json NODE_PATH=. node scripts/updateRequestsInPlex.js",
"docs": "yarn apiDocs; yarn classDocs",
"apiDocs": "",
"classDocs": "./script/generate-class-docs.sh"
"update": "cross-env SEASONED_CONFIG=conf/development.json NODE_PATH=. node src/plex/updateRequestsInPlex.js"
},
"dependencies": {
"axios": "^0.18.0",
"bcrypt": "^5.0.1",
"bcrypt-nodejs": "^0.0.3",
"body-parser": "~1.18.2",
"cookie-parser": "^1.4.6",
"cross-env": "~5.1.4",
"express": "~4.16.0",
"form-data": "^2.5.1",
"jsonwebtoken": "^8.5.1",
"jsonwebtoken": "^8.0.1",
"km-moviedb": "^0.2.13",
"mongoose": "~5.0.11",
"km-moviedb": "^0.2.12",
"node-cache": "^4.1.1",
"node-fetch": "^2.6.0",
"python-shell": "^0.5.0",
"raven": "^2.4.2",
"redis": "^3.0.2",
"request": "^2.87.0",
"request": "^2.85.0",
"request-promise": "^4.2",
"sqlite3": "^5.0.1"
"sqlite3": "^4.0.0"
},
"devDependencies": {
"@babel/core": "^7.5.5",
"@babel/node": "^7.5.5",
"@babel/preset-env": "^7.5.5",
"@babel/register": "^7.5.5",
"@types/node": "^12.6.8",
"coveralls": "^3.0.5",
"documentation": "^12.0.3",
"coveralls": "^3.0.0",
"eslint": "^4.9.0",
"eslint-config-airbnb-base": "^12.1.0",
"eslint-plugin-import": "^2.8.0",
"istanbul": "^0.4.5",
"mocha": "^6.2.0",
"mocha": "^5.0.4",
"mocha-lcov-reporter": "^1.3.0",
"nyc": "^11.6.0",
"raven": "^2.4.2",
"supertest": "^3.0.0",
"supertest-as-promised": "^4.0.1",
"typescript": "^3.5.3"
"supertest-as-promised": "^4.0.1"
}
}

44
seasoned_api/scripts/updateRequestsInPlex.js
View File

@@ -1,44 +0,0 @@
const Plex = require("src/plex/plex");
const configuration = require("src/config/configuration").getInstance();
const plex = new Plex(configuration.get("plex", "ip"));
const establishedDatabase = require("src/database/database");
const queries = {
getRequestsNotYetInPlex: `SELECT * FROM requests WHERE status = 'requested' OR status = 'downloading'`,
saveNewStatus: `UPDATE requests SET status = ? WHERE id IS ? and type IS ?`
};
const getByStatus = () =>
establishedDatabase.all(queries.getRequestsNotYetInPlex);
const checkIfRequestExistInPlex = async request => {
request.existsInPlex = await plex.existsInPlex(request);
return request;
};
const commitNewStatus = (status, id, type, title) => {
console.log(type, title, "updated to:", status);
return establishedDatabase.run(queries.saveNewStatus, [status, id, type]);
};
const getNewRequestMatchesInPlex = async () => {
const requests = await getByStatus();
return Promise.all(requests.map(checkIfRequestExistInPlex))
.catch(error =>
console.log("error from checking plex for existance:", error)
)
.then(matchedRequests =>
matchedRequests.filter(request => request.existsInPlex)
);
};
const updateMatchInDb = (match, status) => {
return commitNewStatus(status, match.id, match.type, match.title);
};
getNewRequestMatchesInPlex()
.then(newMatches =>
Promise.all(newMatches.map(match => updateMatchInDb(match, "downloaded")))
)
.then(() => process.exit(0));

52
seasoned_api/src/cache/redis.js vendored
View File

@@ -1,52 +0,0 @@
const redis = require("redis")
const client = redis.createClient()
class Cache {
/**
* Retrieve an unexpired cache entry by key.
* @param {String} key of the cache entry
* @returns {Promise}
*/
get(key) {
return new Promise((resolve, reject) => {
client.get(key, (error, reply) => {
if (reply == null) {
return reject();
}
resolve(JSON.parse(reply));
});
});
}
/**
* Insert cache entry with key and value.
* @param {String} key of the cache entry
* @param {String} value of the cache entry
* @param {Number} timeToLive the number of seconds before entry expires
* @returns {Object}
*/
set(key, value, timeToLive = 10800) {
if (value == null || key == null) return null;
const json = JSON.stringify(value);
client.set(key, json, (error, reply) => {
if (reply == "OK") {
// successfully set value with key, now set TTL for key
client.expire(key, timeToLive, e => {
if (e)
console.error(
"Unexpected error while setting expiration for key:",
key,
". Error:",
error
);
});
}
});
return value;
}
}
module.exports = Cache;

4
seasoned_api/src/config/configuration.js
View File

@@ -22,13 +22,13 @@ class Config {
get(section, option) {
if (this.fields[section] === undefined || this.fields[section][option] === undefined) {
throw new Error(`Field "${section} => ${option}" does not exist.`);
throw new Error(`Filed "${section} => ${option}" does not exist.`);
}
const field = new Field(this.fields[section][option]);
if (field.value === '') {
const envField = process.env[[section.toUpperCase(), option.toUpperCase()].join('_')];
const envField = process.env[['SEASONED', section.toUpperCase(), option.toUpperCase()].join('_')];
if (envField !== undefined && envField.length !== 0) { return envField; }
}

17
seasoned_api/src/database/schemas/setup.sql
View File

@@ -1,19 +1,11 @@
CREATE TABLE IF NOT EXISTS user (
user_name varchar(127) UNIQUE,
password varchar(127),
admin boolean DEFAULT 0,
email varchar(127) UNIQUE,
admin boolean DEFAULT 0,
primary key (user_name)
);
CREATE TABLE IF NOT EXISTS settings (
user_name varchar(127) UNIQUE,
dark_mode boolean DEFAULT 0,
plex_userid varchar(127) DEFAULT NULL,
emoji varchar(16) DEFAULT NULL,
foreign key(user_name) REFERENCES user(user_name) ON DELETE CASCADE
);
CREATE TABLE IF NOT EXISTS cache (
key varchar(255),
value blob,
@@ -31,18 +23,17 @@ CREATE TABLE IF NOT EXISTS search_history (
);
CREATE TABLE IF NOT EXISTS requests(
id NUMBER,
id TEXT,
title TEXT,
year NUMBER,
poster_path TEXT DEFAULT NULL,
background_path TEXT DEFAULT NULL,
requested_by varchar(127) DEFAULT NULL,
requested_by TEXT,
ip TEXT,
date DATE DEFAULT CURRENT_TIMESTAMP,
status CHAR(25) DEFAULT 'requested' NOT NULL,
user_agent CHAR(255) DEFAULT NULL,
type CHAR(50) DEFAULT 'movie',
foreign key(requested_by) REFERENCES user(user_name) ON DELETE SET NULL
type CHAR(50) DEFAULT 'movie'
);
CREATE TABLE IF NOT EXISTS request(

1
seasoned_api/src/database/schemas/teardown.sql
View File

@@ -1,5 +1,4 @@
DROP TABLE IF EXISTS user;
DROP TABLE IF EXISTS settings;
DROP TABLE IF EXISTS search_history;
DROP TABLE IF EXISTS requests;
DROP TABLE IF EXISTS request;

9
seasoned_api/src/database/sqliteDatabase.js
View File

@@ -6,7 +6,6 @@ class SqliteDatabase {
constructor(host) {
this.host = host;
this.connection = new sqlite3.Database(this.host);
this.execute('pragma foreign_keys = on;');
this.schemaDirectory = path.join(__dirname, 'schemas');
}
@@ -26,7 +25,7 @@ class SqliteDatabase {
* @param {Array} parameters in the SQL query
* @returns {Promise}
*/
run(sql, parameters) {
async run(sql, parameters) {
return new Promise((resolve, reject) => {
this.connection.run(sql, parameters, (error, result) => {
if (error)
@@ -42,7 +41,7 @@ class SqliteDatabase {
* @param {Array} parameters in the SQL query
* @returns {Promise}
*/
all(sql, parameters) {
async all(sql, parameters) {
return new Promise((resolve, reject) => {
this.connection.all(sql, parameters, (err, rows) => {
if (err) {
@@ -59,7 +58,7 @@ class SqliteDatabase {
* @param {Array} parameters in the SQL query
* @returns {Promise}
*/
get(sql, parameters) {
async get(sql, parameters) {
return new Promise((resolve, reject) => {
this.connection.get(sql, parameters, (err, rows) => {
if (err) {
@@ -76,7 +75,7 @@ class SqliteDatabase {
* @param {Array} parameters in the SQL query
* @returns {Promise}
*/
execute(sql) {
async execute(sql) {
return new Promise(resolve => {
this.connection.exec(sql, (err, database) => {
if (err) {

35
seasoned_api/src/notifications/sms.js
View File

@@ -1,35 +0,0 @@
const request = require("request");
const configuration = require('src/config/configuration').getInstance();
const sendSMS = (message) => {
const apiKey = configuration.get('sms', 'apikey')
if (!apiKey) {
console.warning("api key for sms not set, cannot send sms.")
return null
}
const sender = configuration.get('sms', 'sender')
const recipient = configuration.get('sms', 'recipient')
return new Promise((resolve, reject) => {
request.post(
{
url: `https://gatewayapi.com/rest/mtsms?token=${apiKey}`,
json: true,
body: {
sender,
message,
recipients: [{ msisdn: `47${recipient}` }]
}
},
function(err, r, body) {
console.log(err ? err : body);
console.log("sms provider response:", body)
resolve()
}
);
})
}
module.exports = { sendSMS }

121
seasoned_api/src/pirate/pirateRepository.js
View File

@@ -1,104 +1,87 @@
const assert = require("assert");
const http = require("http");
const { URL } = require("url");
const PythonShell = require("python-shell");
const assert = require('assert');
const http = require('http');
const { URL } = require('url');
const PythonShell = require('python-shell');
const establishedDatabase = require("src/database/database");
const RedisCache = require("src/cache/redis");
const cache = new RedisCache();
const establishedDatabase = require('src/database/database');
function getMagnetFromURL(url) {
return new Promise((resolve, reject) => {
const options = new URL(url);
if (options.protocol.includes("magnet")) resolve(url);
return new Promise((resolve, reject) => {
const options = new URL(url);
if (options.protocol.includes('magnet'))
resolve(url)
http.get(options, res => {
if (res.statusCode == 301 || res.statusCode == 302) {
resolve(res.headers.location);
}
});
});
http.get(options, (res) => {
if (res.statusCode == 301) {
resolve(res.headers.location)
}
});
});
}
async function find(searchterm, callback) {
const options = {
pythonPath: "../torrent_search/env/bin/python3",
scriptPath: "../torrent_search",
args: [searchterm, "-s", "jackett", "--print"]
};
const options = {
pythonPath: '../torrent_search/env/bin/python3.6',
scriptPath: '../torrent_search',
args: [searchterm, '-s', 'jackett', '-f', '--print']
}
PythonShell.run("torrentSearch/search.py", options, callback);
// PythonShell does not support return
PythonShell.run('torrentSearch/search.py', options, callback);
// PythonShell does not support return
}
async function callPythonAddMagnet(url, callback) {
getMagnetFromURL(url)
.then(magnet => {
getMagnetFromURL(url)
.then((magnet) => {
const options = {
pythonPath: "../delugeClient/env/bin/python3",
scriptPath: "../delugeClient",
args: ["add", magnet]
pythonPath: '../delugeClient/env/bin/python3.6',
scriptPath: '../delugeClient',
args: ['add', magnet]
};
PythonShell.run("deluge_cli.py", options, callback);
})
.catch(err => {
PythonShell.run('deluge_cli.py', options, callback);
})
.catch((err) => {
console.log(err);
throw new Error(err);
});
})
}
async function SearchPiratebay(query) {
if (query && query.includes("+")) {
query = query.replace("+", "%20");
}
const cacheKey = `pirate/${query}`;
return new Promise((resolve, reject) =>
cache
.get(cacheKey)
.then(resolve)
.catch(() =>
find(query, (err, results) => {
if (err) {
console.log("THERE WAS A FUCKING ERROR!\n", err);
reject(Error("There was a error when searching for torrents"));
}
if (results) {
const jsonData = JSON.parse(results[1], null, "\t");
cache.set(cacheKey, jsonData);
resolve(jsonData);
}
})
)
);
return await new Promise((resolve, reject) => find(query, (err, results) => {
if (err) {
/* eslint-disable no-console */
console.log('THERE WAS A FUCKING ERROR!\n', err);
reject(Error('There was a error when searching for torrents'));
}
if (results) {
/* eslint-disable no-console */
console.log('result', results);
resolve(JSON.parse(results, null, '\t'));
}
}));
}
async function AddMagnet(magnet, name, tmdb_id) {
return await new Promise((resolve, reject) =>
callPythonAddMagnet(magnet, (err, results) => {
return await new Promise((resolve, reject) => callPythonAddMagnet(magnet, (err, results) => {
if (err) {
/* eslint-disable no-console */
console.log(err);
reject(Error("Enable to add torrent", err));
/* eslint-disable no-console */
console.log(err);
reject(Error('Enable to add torrent', err))
}
/* eslint-disable no-console */
console.log("result/error:", err, results);
console.log('result/error:', err, results);
database = establishedDatabase;
insert_query =
"INSERT INTO requested_torrent(magnet,torrent_name,tmdb_id) \
insert_query = "INSERT INTO requested_torrent(magnet,torrent_name,tmdb_id) \
VALUES (?,?,?)";
let response = database.run(insert_query, [magnet, name, tmdb_id]);
console.log("Response from requsted_torrent insert: " + response);
console.log('Response from requsted_torrent insert: ' + response);
resolve({ success: true });
})
);
}));
}
module.exports = { SearchPiratebay, AddMagnet };

269
seasoned_api/src/plex/plex.js
View File

@@ -1,240 +1,59 @@
const fetch = require("node-fetch");
const convertPlexToMovie = require("src/plex/convertPlexToMovie");
const convertPlexToShow = require("src/plex/convertPlexToShow");
const convertPlexToEpisode = require("src/plex/convertPlexToEpisode");
const { Movie, Show, Person } = require("src/tmdb/types");
const RedisCache = require("src/cache/redis");
const redisCache = new RedisCache();
const sanitize = string => string.toLowerCase().replace(/[^\w]/gi, "");
function fixedEncodeURIComponent(str) {
return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
return "%" + c.charCodeAt(0).toString(16).toUpperCase();
});
}
const matchingTitleAndYear = (plex, tmdb) => {
let matchingTitle, matchingYear;
if (plex["title"] != null && tmdb["title"] != null) {
const plexTitle = sanitize(plex.title);
const tmdbTitle = sanitize(tmdb.title);
matchingTitle = plexTitle == tmdbTitle;
matchingTitle = matchingTitle
? matchingTitle
: plexTitle.startsWith(tmdbTitle);
} else matchingTitle = false;
if (plex["year"] != null && tmdb["year"] != null)
matchingYear = plex.year == tmdb.year;
else matchingYear = false;
return matchingTitle && matchingYear;
};
const successfullResponse = response => {
if (response && response["MediaContainer"]) return response;
if (
response == null ||
response["status"] == null ||
response["statusText"] == null
) {
throw Error("Unable to decode response");
}
const { status, statusText } = response;
if (status === 200) {
return response.json();
} else {
throw { message: statusText, status: status };
}
};
const axios = require('axios')
const convertPlexToMovie = require('src/plex/convertPlexToMovie')
const convertPlexToShow = require('src/plex/convertPlexToShow')
const convertPlexToEpisode = require('src/plex/convertPlexToEpisode')
class Plex {
constructor(ip, port = 32400, cache = null) {
this.plexIP = ip;
this.plexPort = port;
this.cache = cache || redisCache;
this.cacheTags = {
machineInfo: "plex/mi",
search: "plex/s"
};
constructor(ip) {
this.plexIP = ip
this.plexPort = 32400
}
fetchMachineIdentifier() {
const cacheKey = `${this.cacheTags.machineInfo}`;
const url = `http://${this.plexIP}:${this.plexPort}/`;
const options = {
timeout: 20000,
headers: { Accept: "application/json" }
};
return new Promise((resolve, reject) =>
this.cache
.get(cacheKey)
.then(machineInfo => resolve(machineInfo["machineIdentifier"]))
.catch(() => fetch(url, options))
.then(response => response.json())
.then(machineInfo =>
this.cache.set(cacheKey, machineInfo["MediaContainer"], 2628000)
)
.then(machineInfo => resolve(machineInfo["machineIdentifier"]))
.catch(error => {
if (error != undefined && error.type === "request-timeout") {
reject({
message: "Plex did not respond",
status: 408,
success: false
});
}
reject(error);
existsInPlex(tmdbMovie) {
return Promise.resolve()
.then(() => this.search(tmdbMovie.title))
// TODO handle this when whitelist of local ip is not set in plex
.catch((error) => { console.error('Unable to search plex')})
.then((plexMovies) => {
const matches = plexMovies.some((plexMovie) => {
return tmdbMovie.title === plexMovie.title && tmdbMovie.type === plexMovie.type
})
);
}
matchTmdbAndPlexMedia(plex, tmdb) {
let match;
if (plex == null || tmdb == null) return false;
if (plex instanceof Array) {
let possibleMatches = plex.map(plexItem =>
matchingTitleAndYear(plexItem, tmdb)
);
match = possibleMatches.includes(true);
} else {
match = matchingTitleAndYear(plex, tmdb);
}
return match;
}
async existsInPlex(tmdb) {
const plexMatch = await this.findPlexItemByTitleAndYear(
tmdb.title,
tmdb.year
);
return plexMatch ? true : false;
}
findPlexItemByTitleAndYear(title, year) {
const query = { title, year };
return this.search(title).then(plexResults => {
const matchesInPlex = plexResults.map(plex =>
this.matchTmdbAndPlexMedia(plex, query)
);
const matchesIndex = matchesInPlex.findIndex(el => el === true);
return matchesInPlex != -1 ? plexResults[matchesIndex] : null;
});
}
getDirectLinkByTitleAndYear(title, year) {
const machineIdentifierPromise = this.fetchMachineIdentifier();
const matchingObjectInPlexPromise = this.findPlexItemByTitleAndYear(
title,
year
);
return Promise.all([
machineIdentifierPromise,
matchingObjectInPlexPromise
]).then(([machineIdentifier, matchingObjectInPlex]) => {
if (
matchingObjectInPlex == false ||
matchingObjectInPlex == null ||
matchingObjectInPlex["key"] == null ||
machineIdentifier == null
)
return false;
const keyUriComponent = fixedEncodeURIComponent(matchingObjectInPlex.key);
return `https://app.plex.tv/desktop#!/server/${machineIdentifier}/details?key=${keyUriComponent}`;
});
tmdbMovie.existsInPlex = matches
return tmdbMovie
})
}
search(query) {
const cacheKey = `${this.cacheTags.search}:${query}`;
const url = `http://${this.plexIP}:${
this.plexPort
}/hubs/search?query=${fixedEncodeURIComponent(query)}`;
const options = {
timeout: 20000,
headers: { Accept: "application/json" }
};
return new Promise((resolve, reject) =>
this.cache
.get(cacheKey)
.catch(() => fetch(url, options)) // else fetch fresh data
.then(successfullResponse)
.then(results => this.cache.set(cacheKey, results, 21600)) // 6 hours
.then(this.mapResults)
.then(resolve)
.catch(error => {
if (error != undefined && error.type === "request-timeout") {
reject({
message: "Plex did not respond",
status: 408,
success: false
});
}
reject(error);
})
);
}
// this is not guarenteed to work, but if we see a movie or
// show has been imported, this function can be helpfull to call
// in order to try bust the cache preventing movieInfo and
// showInfo from seeing updates through existsInPlex.
bustSearchCacheWithTitle(title) {
const query = title;
const cacheKey = `${this.cacheTags.search}/${query}*`;
this.cache.del(
cacheKey,
(error,
response => {
if (response == 1) return true;
// TODO improve cache key matching by lowercasing it on the backend.
// what do we actually need to check for if the key was deleted or not
// it might be an error or another response code.
console.log("Unable to delete, key might not exists");
})
);
}
mapResults(response) {
if (
response == null ||
response.MediaContainer == null ||
response.MediaContainer.Hub == null
) {
return [];
baseURL: `http://${this.plexIP}:${this.plexPort}`,
url: '/hubs/search',
params: { query: query },
responseType: 'json',
timeout: 3000
}
return response.MediaContainer.Hub.filter(category => category.size > 0)
.map(category => {
if (category.type === "movie") {
return category.Metadata;
} else if (category.type === "show") {
return category.Metadata.map(convertPlexToShow);
} else if (category.type === "episode") {
return category.Metadata.map(convertPlexToEpisode);
}
})
.filter(result => result !== undefined);
return Promise.resolve()
.then(() => axios.request(options))
.catch((error) => { throw new Error(`Unable to search plex library`, error) })
.then(response => this.mapResults(response))
}
mapResults(response) {
return response.data.MediaContainer.Hub.reduce((result, hub) => {
if (hub.type === 'movie' && hub.Metadata !== undefined) {
return [...result, ...hub.Metadata.map(convertPlexToMovie)]
}
else if (hub.type === 'show' && hub.Metadata !== undefined) {
return [...result, ...hub.Metadata.map(convertPlexToShow)]
}
else if (hub.type === 'episode' && hub.Metadata !== undefined) {
return [...result, ...hub.Metadata.map(convertPlexToEpisode)]
}
return result
}, [])
}
}

193
seasoned_api/src/plex/requestRepository.js
View File

@@ -1,130 +1,101 @@
const PlexRepository = require("src/plex/plexRepository");
const configuration = require("src/config/configuration").getInstance();
const TMDB = require("src/tmdb/tmdb");
const establishedDatabase = require("src/database/database");
const PlexRepository = require('src/plex/plexRepository');
const Cache = require('src/tmdb/cache');
const configuration = require('src/config/configuration').getInstance();
const TMDB = require('src/tmdb/tmdb');
const establishedDatabase = require('src/database/database');
const plexRepository = new PlexRepository(configuration.get("plex", "ip"));
const tmdb = new TMDB(configuration.get("tmdb", "apiKey"));
const plexRepository = new PlexRepository(configuration.get('plex', 'ip'));
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
class RequestRepository {
constructor(database) {
this.database = database || establishedDatabase;
this.queries = {
insertRequest: `INSERT INTO requests(id,title,year,poster_path,background_path,requested_by,ip,user_agent,type)
constructor(database) {
this.database = database || establishedDatabase;
this.queries = {
insertRequest: `INSERT INTO requests(id,title,year,poster_path,background_path,requested_by,ip,user_agent,type)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
fetchRequestedItems:
"SELECT * FROM requests ORDER BY date DESC LIMIT 25 OFFSET ?*25-25",
fetchRequestedItemsByStatus:
"SELECT * FROM requests WHERE status IS ? AND type LIKE ? ORDER BY date DESC LIMIT 25 OFFSET ?*25-25",
updateRequestedById:
"UPDATE requests SET status = ? WHERE id is ? AND type is ?",
checkIfIdRequested: "SELECT * FROM requests WHERE id IS ? AND type IS ?",
userRequests:
"SELECT * FROM requests WHERE requested_by IS ? ORDER BY date DESC"
};
this.cacheTags = {
search: "se",
lookup: "i"
};
}
fetchRequestedItems: 'SELECT * FROM requests ORDER BY date DESC LIMIT 25 OFFSET ?*25-25',
fetchRequestedItemsByStatus: 'SELECT * FROM requests WHERE status IS ? AND type LIKE ? ORDER BY date DESC LIMIT 25 OFFSET ?*25-25',
updateRequestedById: 'UPDATE requests SET status = ? WHERE id is ? AND type is ?',
checkIfIdRequested: 'SELECT * FROM requests WHERE id IS ? AND type IS ?',
userRequests: 'SELECT * FROM requests WHERE requested_by IS ? ORDER BY date DESC',
};
this.cacheTags = {
search: 'se',
lookup: 'i',
};
}
search(query, type, page) {
return Promise.resolve()
.then(() => tmdb.search(query, type, page))
.catch(error => Error(`error in the house${error}`));
}
search(query, type, page) {
return Promise.resolve()
.then(() => tmdb.search(query, type, page))
.catch(error => Error(`error in the house${error}`));
}
lookup(identifier, type = "movie") {
return Promise.resolve()
.then(() => tmdb.lookup(identifier, type))
.then(tmdbMovie => this.checkID(tmdbMovie))
.then(tmdbMovie => plexRepository.inPlex(tmdbMovie))
.catch(error => {
throw new Error(error);
});
}
lookup(identifier, type = 'movie') {
return Promise.resolve()
.then(() => tmdb.lookup(identifier, type))
.then(tmdbMovie => this.checkID(tmdbMovie))
.then(tmdbMovie => plexRepository.inPlex(tmdbMovie))
.catch((error) => {
throw new Error(error);
});
}
checkID(tmdbMovie) {
return Promise.resolve()
.then(() =>
this.database.get(this.queries.checkIfIdRequested, [
tmdbMovie.id,
tmdbMovie.type
])
)
.then((result, error) => {
if (error) {
throw new Error(error);
}
tmdbMovie.requested = result ? true : false;
return tmdbMovie;
});
}
checkID(tmdbMovie) {
return Promise.resolve()
.then(() => this.database.get(this.queries.checkIfIdRequested, [tmdbMovie.id, tmdbMovie.type]))
.then((result, error) => {
if (error) { throw new Error(error); }
tmdbMovie.requested = result ? true : false;
return tmdbMovie;
});
}
/**
/**
* Send request for given media id.
* @param {identifier, type} the id of the media object and type of media must be defined
* @returns {Promise} If nothing has gone wrong.
*/
sendRequest(identifier, type, ip, user_agent, user) {
return Promise.resolve()
.then(() => tmdb.lookup(identifier, type))
.then(movie => {
const username = user === undefined ? undefined : user.username;
// Add request to database
return this.database.run(this.queries.insertRequest, [
movie.id,
movie.title,
movie.year,
movie.poster_path,
movie.background_path,
username,
ip,
user_agent,
movie.type
]);
sendRequest(identifier, type, ip, user_agent, user) {
return Promise.resolve()
.then(() => tmdb.lookup(identifier, type))
.then((movie) => {
const username = user === undefined ? undefined : user.username;
// Add request to database
return this.database.run(this.queries.insertRequest, [movie.id, movie.title, movie.year, movie.poster_path, movie.background_path, username, ip, user_agent, movie.type]);
});
}
}
fetchRequested(status, page = "1", type = "%") {
return Promise.resolve().then(() => {
if (
status === "requested" ||
status === "downloading" ||
status === "downloaded"
)
return this.database.all(this.queries.fetchRequestedItemsByStatus, [
status,
type,
page
]);
else return this.database.all(this.queries.fetchRequestedItems, page);
});
}
fetchRequested(status, page = '1', type = '%') {
return Promise.resolve()
.then(() => {
if (status === 'requested' || status === 'downloading' || status === 'downloaded')
return this.database.all(this.queries.fetchRequestedItemsByStatus, [status, type, page]);
else
return this.database.all(this.queries.fetchRequestedItems, page);
})
}
userRequests(username) {
return Promise.resolve()
.then(() => this.database.all(this.queries.userRequests, username))
.catch(error => {
if (String(error).includes("no such column")) {
throw new Error("Username not found");
}
throw new Error("Unable to fetch your requests");
})
.then(result => {
// TODO do a correct mapping before sending, not just a dump of the database
result.map(item => (item.poster = item.poster_path));
return result;
});
}
userRequests(user) {
return Promise.resolve()
.then(() => this.database.all(this.queries.userRequests, user.username))
.catch((error) => {
if (String(error).includes('no such column')) {
throw new Error('Username not found');
}
throw new Error('Unable to fetch your requests');
})
.then((result) => {
// TODO do a correct mapping before sending, not just a dump of the database
result.map(item => item.poster = item.poster_path)
return result
});
}
updateRequestedById(id, type, status) {
return this.database.run(this.queries.updateRequestedById, [
status,
id,
type
]);
}
updateRequestedById(id, type, status) {
return this.database.run(this.queries.updateRequestedById, [status, id, type]);
}
}
module.exports = RequestRepository;

1
seasoned_api/src/plex/types/show.js
View File

@@ -6,6 +6,7 @@ class Show {
this.rating = null;
this.seasons = null;
this.episodes = null;
this.type = 'show';
}
}

50
seasoned_api/src/request/request.js
View File

@@ -1,7 +1,9 @@
const assert = require('assert')
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const tmdb = new TMDB(configuration.get('tmdb', 'apiKey'));
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
const establishedDatabase = require('src/database/database');
const utils = require('./utils');
@@ -21,7 +23,6 @@ class RequestRepository {
downloaded: '(select status from requests where id is request.id and type is request.type limit 1)',
// deluge: '(select status from deluge_torrent where id is request.id and type is request.type limit 1)',
// fetchAllFilterStatus: 'select * from request where '
readWithoutUserData: 'select id, title, year, type, status, date from requests where id is ? and type is ?',
read: 'select id, title, year, type, status, requested_by, ip, date, user_agent from requests where id is ? and type is ?'
};
}
@@ -84,18 +85,18 @@ class RequestRepository {
* @param {tmdb} tmdb class of movie|show to add
* @returns {Promise}
*/
requestFromTmdb(tmdb, ip, user_agent, username) {
requestFromTmdb(tmdb, ip, user_agent, user) {
return Promise.resolve()
.then(() => this.database.get(this.queries.read, [tmdb.id, tmdb.type]))
.then(row => assert.equal(row, undefined, 'Id has already been requested'))
.then(() => this.database.run(this.queries.add, [tmdb.id, tmdb.title, tmdb.year, tmdb.poster, tmdb.backdrop, username, ip, user_agent, tmdb.type]))
.catch((error) => {
if (error.name === 'AssertionError' || error.message.endsWith('been requested')) {
throw new Error('This id is already requested', error.message);
}
console.log('Error @ request.addTmdb:', error);
throw new Error('Could not add request');
});
.then(() => this.database.get(this.queries.read, [tmdb.id, tmdb.type]))
.then(row => assert.equal(row, undefined, 'Id has already been requested'))
.then(() => this.database.run(this.queries.add, [tmdb.id, tmdb.title, tmdb.year, tmdb.poster, tmdb.backdrop, user, ip, user_agent, tmdb.type]))
.catch((error) => {
if (error.name === 'AssertionError' || error.message.endsWith('been requested')) {
throw new Error('This id is already requested', error.message);
}
console.log('Error @ request.addTmdb:', error);
throw new Error('Could not add request');
});
}
/**
@@ -105,17 +106,11 @@ class RequestRepository {
* @returns {Promise}
*/
getRequestByIdAndType(id, type) {
return this.database.get(this.queries.readWithoutUserData, [id, type])
return Promise.resolve()
.then(() => this.database.get(this.queries.read, [id, type]))
.then(row => {
assert(row, 'Could not find request item with that id and type')
return {
id: row.id,
title: row.title,
year: row.year,
type: row.type,
status: row.status,
requested_date: new Date(row.date)
}
return JSON.stringify(row)
})
}
@@ -129,7 +124,6 @@ class RequestRepository {
*/
fetchAll(page=1, sort_by=undefined, sort_direction='asc', filter=undefined, query=undefined) {
// TODO implemented sort and filter
page = parseInt(page)
let fetchQuery = this.queries.fetchAll
let fetchTotalResults = this.queries.totalRequests
let fetchParams = [page]
@@ -150,15 +144,11 @@ class RequestRepository {
const totalRequests = sqliteResponse['totalRequests']
const totalPages = Math.ceil(totalRequests / 26)
return [ rows.map(item => {
item.poster = item.poster_path; delete item.poster_path;
item.backdrop = item.background_path; delete item.background_path;
return item
}), totalPages, totalRequests ]
return [ rows.map(item => { item.poster = item.poster_path; return item }), totalPages ]
return Promise.all(this.mapToTmdbByType(rows))
})
.then(([result, totalPages, totalRequests]) => Promise.resolve({
results: result, total_results: totalRequests, page: page, total_pages: totalPages
.then(([result, totalPages]) => Promise.resolve({
results: result, total_results: result.length, page: page, total_pages: totalPages
}))
.catch(error => { console.log(error);throw error })
}

16
seasoned_api/src/searchHistory/searchHistory.js
View File

@@ -28,23 +28,17 @@ class SearchHistory {
/**
* Creates a new search entry in the database.
* @param {String} username logged in user doing the search
* @param {User} user a new user
* @param {String} searchQuery the query the user searched for
* @returns {Promise}
*/
create(username, searchQuery) {
return this.database.run(this.queries.create, [searchQuery, username])
.catch(error => {
create(user, searchQuery) {
return Promise.resolve()
.then(() => this.database.run(this.queries.create, [searchQuery, user]))
.catch((error) => {
if (error.message.includes('FOREIGN')) {
throw new Error('Could not create search history.');
}
throw {
success: false,
status: 500,
message: 'An unexpected error occured',
source: 'database'
}
});
}
}

74
seasoned_api/src/tautulli/tautulli.js
View File

@@ -1,74 +0,0 @@
const fetch = require("node-fetch");
class Tautulli {
constructor(apiKey, ip, port) {
this.apiKey = apiKey;
this.ip = ip;
this.port = port;
}
buildUrlWithCmdAndUserid(cmd, user_id) {
const url = new URL("api/v2", `http://${this.ip}:${this.port}`);
url.searchParams.append("apikey", this.apiKey);
url.searchParams.append("cmd", cmd);
url.searchParams.append("user_id", user_id);
return url;
}
logTautulliError(error) {
console.error("error fetching from tautulli");
throw error;
}
getPlaysByDayOfWeek(plex_userid, days, y_axis) {
const url = this.buildUrlWithCmdAndUserid(
"get_plays_by_dayofweek",
plex_userid
);
url.searchParams.append("time_range", days);
url.searchParams.append("y_axis", y_axis);
return fetch(url.href)
.then(resp => resp.json())
.catch(error => this.logTautulliError(error));
}
getPlaysByDays(plex_userid, days, y_axis) {
const url = this.buildUrlWithCmdAndUserid("get_plays_by_date", plex_userid);
url.searchParams.append("time_range", days);
url.searchParams.append("y_axis", y_axis);
return fetch(url.href)
.then(resp => resp.json())
.catch(error => this.logTautulliError(error));
}
watchTimeStats(plex_userid) {
const url = this.buildUrlWithCmdAndUserid(
"get_user_watch_time_stats",
plex_userid
);
url.searchParams.append("grouping", 0);
return fetch(url.href)
.then(resp => resp.json())
.catch(error => this.logTautulliError(error));
}
viewHistory(plex_userid) {
const url = this.buildUrlWithCmdAndUserid("get_history", plex_userid);
url.searchParams.append("start", 0);
url.searchParams.append("length", 50);
console.log("fetching url", url.href);
return fetch(url.href)
.then(resp => resp.json())
.catch(error => this.logTautulliError(error));
}
}
module.exports = Tautulli;

3
seasoned_api/src/tmdb/.babelrc
View File

@@ -1,3 +0,0 @@
{
"presets": ["@babel/preset-env"]
}

12
seasoned_api/src/tmdb/cache.js
View File

@@ -18,12 +18,12 @@ class Cache {
* @returns {Object}
*/
get(key) {
return Promise.resolve()
.then(() => this.database.get(this.queries.read, [key]))
.then(row => {
assert(row, 'Could not find cache entry with that key.');
return JSON.parse(row.value);
})
return Promise.resolve()
.then(() => this.database.get(this.queries.read, [key]))
.then((row) => {
assert(row, 'Could not find cache enrty with that key.');
return JSON.parse(row.value);
});
}
/**

49
seasoned_api/src/tmdb/convertTmdbToMovie.js Normal file
View File

@@ -0,0 +1,49 @@
const Movie = require('src/tmdb/types/movie');
const tmdbSwitcher = (tmdbMovie, property) => tmdbMovie[property]
function convertTmdbToMovie(tmdbMovie, credits=undefined) {
const movie = new Movie(tmdbMovie.id, tmdbMovie.title)
movie.overview = tmdbMovie.overview;
movie.rank = tmdbMovie.vote_average;
if (credits) {
movie.credits = credits;
}
if (tmdbMovie.release_date !== undefined) {
movie.release_date = new Date(tmdbMovie.release_date);
movie.year = movie.release_date.getFullYear();
}
if (tmdbMovie.poster_path !== undefined) {
movie.poster = tmdbMovie.poster_path;
}
if (tmdbMovie.backdrop_path !== undefined) {
movie.backdrop = tmdbMovie.backdrop_path;
}
if (tmdbMovie.status !== undefined) {
movie.status = tmdbMovie.status;
}
if (tmdbMovie.genres !== undefined) {
movie.genres = tmdbMovie.genres.map(genre => genre.name);
}
if (tmdbMovie.tagline !== undefined) {
movie.tagline = tmdbMovie.tagline;
}
if (tmdbMovie.runtime !== undefined) {
movie.runtime = tmdbMovie.runtime;
}
if (tmdbMovie.imdb_id !== undefined) {
movie.imdb_id = tmdbMovie.imdb_id;
}
return movie;
}
module.exports = convertTmdbToMovie;

30
seasoned_api/src/tmdb/convertTmdbToPerson.js Normal file
View File

@@ -0,0 +1,30 @@
const Person = require('src/tmdb/types/person');
const convertTmdbToMovie = require('src/tmdb/convertTmdbToMovie');
function convertTmdbToPerson(tmdbPerson, cast=undefined) {
const person = new Person(tmdbPerson.id, tmdbPerson.name);
if (tmdbPerson.profile_path !== undefined) {
person.poster = tmdbPerson.profile_path;
}
if (tmdbPerson.birthday !== undefined) {
person.birthday = new Date(tmdbPerson.birthday);
}
if (tmdbPerson.deathday !== undefined) {
person.deathday = tmdbPerson.deathday;
}
if (tmdbPerson.known_for !== undefined) {
person.known_for = tmdbPerson.known_for.map(convertTmdbToMovie);
}
if (cast) {
person.cast = cast.cast;
}
return person;
}
module.exports = convertTmdbToPerson;

62
seasoned_api/src/tmdb/convertTmdbToSeasoned.js Normal file
View File

@@ -0,0 +1,62 @@
const TMDB = require('src/media_classes/tmdb');
const Movie = require('src/types/movie');
function translateYear(tmdbReleaseDate) {
return new Date(tmdbReleaseDate).getFullYear();
}
function translateGenre(tmdbGenres) {
return tmdbGenres.map(genre => genre.name);
}
function convertType(tmdbType) {
if (tmdbType === 'tv') return 'show';
return undefined;
}
function convertTmdbToMovie(tmdb) {
const year =
const movie = new Movie();
let seasoned = undefined;
if (tmdb.id && tmdb.title && tmdb.release_date) {
const year = tmdb.release_date.getFullYear();
seasoned = new Movie(tmdb.id, tmdb.title, year);
}
else if (tmdb.id && tmdb.name && tmdb.first_air_date) {
const year = tmdb.first_air_date.getFullYear();
seasoned = new Show(tmdb.id, tmdb.name, year);
seasoned.seasons = tmdb.number_of_season;
seasoned.episodes = tmdb.episodes;
return
}
}
const title = tmdb.title || tmdb.name;
const year = translateYear(tmdb.release_date || tmdb.first_air_date);
const type = manualType || convertType(tmdb.type) || 'movie';
const id = tmdb.id;
const summary = tmdb.overview;
const poster_path = tmdb.poster_path;
const background_path = tmdb.backdrop_path;
const popularity = tmdb.popularity;
const score = tmdb.vote_average;
// const genres = translateGenre(tmdb.genres);
const release_status = tmdb.status;
const tagline = tmdb.tagline;
const seasons = tmdb.number_of_seasons;
const episodes = tmdb.episodes;
const seasoned = new TMDB(
title, year, type, id, summary, poster_path, background_path,
popularity, score, release_status, tagline, seasons, episodes
);
// seasoned.print()
return seasoned;
}
module.exports = convertTmdbToSeasoned;

41
seasoned_api/src/tmdb/convertTmdbToShow.js Normal file
View File

@@ -0,0 +1,41 @@
const Show = require('src/tmdb/types/show');
function convertTmdbToShow(tmdbShow, credits=undefined) {
const show = new Show(tmdbShow.id, tmdbShow.name)
show.seasons = tmdbShow.number_of_seasons;
show.episodes = tmdbShow.number_of_episodes;
show.overview = tmdbShow.overview;
show.rank = tmdbShow.vote_average;
if (credits) {
show.credits = credits
}
if (tmdbShow.genres !== undefined) {
show.genres = tmdbShow.genres.map(genre => genre.name);
}
if (tmdbShow.first_air_date !== undefined) {
show.first_air_date = new Date(tmdbShow.first_air_date);
show.year = show.first_air_date.getFullYear();
}
if (tmdbShow.poster_path !== undefined) {
show.poster = tmdbShow.poster_path;
}
if (tmdbShow.backdrop_path !== undefined) {
show.backdrop = tmdbShow.backdrop_path;
}
if (tmdbShow.status !== undefined) {
show.status = tmdbShow.status;
}
if (tmdbShow.episode_run_time !== undefined) {
show.runtime = tmdbShow.runtime;
}
return show;
}
module.exports = convertTmdbToShow;

399
seasoned_api/src/tmdb/tmdb.js
View File

@@ -1,118 +1,94 @@
const moviedb = require("km-moviedb");
const RedisCache = require("src/cache/redis");
const redisCache = new RedisCache();
const {
Movie,
Show,
Person,
Credits,
ReleaseDates
} = require("src/tmdb/types");
const tmdbErrorResponse = (error, typeString = undefined) => {
if (error.status === 404) {
let message = error.response.body.status_message;
throw {
status: 404,
message: message.slice(0, -1) + " in tmdb."
};
} else if (error.status === 401) {
throw {
status: 401,
message: error.response.body.status_message
};
}
throw {
status: 500,
message: `An unexpected error occured while fetching ${typeString} from tmdb`
};
};
const moviedb = require('km-moviedb');
const convertTmdbToMovie = require('src/tmdb/convertTmdbToMovie');
const convertTmdbToShow = require('src/tmdb/convertTmdbToShow');
const convertTmdbToPerson = require('src/tmdb/convertTmdbToPerson');
class TMDB {
constructor(apiKey, cache, tmdbLibrary) {
constructor(cache, apiKey, tmdbLibrary) {
this.cache = cache;
this.tmdbLibrary = tmdbLibrary || moviedb(apiKey);
this.cache = cache || redisCache;
this.cacheTags = {
multiSearch: "mus",
movieSearch: "mos",
showSearch: "ss",
personSearch: "ps",
movieInfo: "mi",
movieCredits: "mc",
movieReleaseDates: "mrd",
movieImages: "mimg",
showInfo: "si",
showCredits: "sc",
personInfo: "pi",
personCredits: "pc",
miscNowPlayingMovies: "npm",
miscPopularMovies: "pm",
miscTopRatedMovies: "tpm",
miscUpcomingMovies: "um",
tvOnTheAir: "toa",
miscPopularTvs: "pt",
miscTopRatedTvs: "trt"
multiSearch: 'mus',
movieSearch: 'mos',
showSearch: 'ss',
personSearch: 'ps',
movieInfo: 'mi',
showInfo: 'si',
personInfo: 'pi',
miscNowPlayingMovies: 'npm',
miscPopularMovies: 'pm',
miscTopRatedMovies: 'tpm',
miscUpcomingMovies: 'um',
tvOnTheAir: 'toa',
miscPopularTvs: 'pt',
miscTopRatedTvs: 'trt',
};
this.defaultTTL = 86400;
}
getFromCacheOrFetchFromTmdb(cacheKey, tmdbMethod, query) {
return new Promise((resolve, reject) =>
this.cache
.get(cacheKey)
.then(resolve)
.catch(() => this.tmdb(tmdbMethod, query))
.then(resolve)
.catch(error => reject(tmdbErrorResponse(error, tmdbMethod)))
);
}
/**
* Retrieve a specific movie by id from TMDB.
* @param {Number} identifier of the movie you want to retrieve
* @param {String} type filter results by type (default movie).
* @returns {Promise} succeeds if movie was found
*/
lookup(identifier, type = 'movie') {
const query = { id: identifier };
const cacheKey = `${this.cacheTags.info}:${type}:${identifier}`;
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => this.tmdb(TMDB_METHODS['info'][type], query))
.catch(() => { throw new Error('Could not find a movie with that id.'); })
.then(response => this.cache.set(cacheKey, response))
.then(response => {
try {
return convertTmdbToSeasoned(response, type);
} catch (parseError) {
console.error(parseError);
throw new Error('Could not parse movie.');
}
});
}
/**
* Retrive search results from TMDB.
* @param {String} text query you want to search for
* @param {Number} page representing pagination of results
* @param {String} type filter results by type (default multi)
* @returns {Promise} dict with query results, current page and total_pages
*/
search(text, page = 1, type = 'multi') {
const query = { query: text, page: page };
const cacheKey = `${this.cacheTags.search}:${page}:${type}:${text}`;
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => this.tmdb(TMDB_METHODS['search'][type], query))
.catch(() => { throw new Error('Could not search for movies/shows at tmdb.'); })
.then(response => this.cache.set(cacheKey, response))
.then(response => this.mapResults(response));
}
/**
* Retrieve a specific movie by id from TMDB.
* @param {Number} identifier of the movie you want to retrieve
* @param {Boolean} add credits (cast & crew) for movie
* @param {Boolean} add release dates for every country
* @param {String} type filter results by type (default movie).
* @returns {Promise} succeeds if movie was found
*/
movieInfo(identifier) {
movieInfo(identifier, credits=false) {
const query = { id: identifier };
const cacheKey = `tmdb/${this.cacheTags.movieInfo}:${identifier}`;
const cacheKey = `${this.cacheTags.movieInfo}:${identifier}:${credits}`;
return this.getFromCacheOrFetchFromTmdb(cacheKey, "movieInfo", query)
.then(movie => this.cache.set(cacheKey, movie, this.defaultTTL))
.then(movie => Movie.convertFromTmdbResponse(movie));
}
const requests = [this.tmdb('movieInfo', query)]
/**
* Retrieve credits for a movie
* @param {Number} identifier of the movie to get credits for
* @returns {Promise} movie cast object
*/
movieCredits(identifier) {
const query = { id: identifier };
const cacheKey = `tmdb/${this.cacheTags.movieCredits}:${identifier}`;
if (credits) {
requests.push(this.tmdb('movieCredits', query))
}
return this.getFromCacheOrFetchFromTmdb(cacheKey, "movieCredits", query)
.then(credits => this.cache.set(cacheKey, credits, this.defaultTTL))
.then(credits => Credits.convertFromTmdbResponse(credits));
}
/**
* Retrieve release dates for a movie
* @param {Number} identifier of the movie to get release dates for
* @returns {Promise} movie release dates object
*/
movieReleaseDates(identifier) {
const query = { id: identifier }
const cacheKey = `tmdb/${this.cacheTags.movieReleaseDates}:${identifier}`
return this.getFromCacheOrFetchFromTmdb(cacheKey, 'movieReleaseDates', query)
.then(releaseDates => this.cache.set(cacheKey, releaseDates, this.defaultTTL))
.then(releaseDates => ReleaseDates.convertFromTmdbResponse(releaseDates))
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => Promise.all(requests))
.catch((error) => { console.log(error); throw new Error('Could not find a movie with that id.'); })
.then(([movies, credits]) => this.cache.set(cacheKey, [movies, credits]))
.then(([movies, credits]) => convertTmdbToMovie(movies, credits))
}
/**
@@ -121,22 +97,22 @@ class TMDB {
* @param {String} type filter results by type (default show).
* @returns {Promise} succeeds if show was found
*/
showInfo(identifier) {
showInfo(identifier, credits=false) {
const query = { id: identifier };
const cacheKey = `tmdb/${this.cacheTags.showInfo}:${identifier}`;
const cacheKey = `${this.cacheTags.showInfo}:${identifier}:${credits}`;
return this.getFromCacheOrFetchFromTmdb(cacheKey, "tvInfo", query)
.then(show => this.cache.set(cacheKey, show, this.defaultTTL))
.then(show => Show.convertFromTmdbResponse(show));
}
const requests = [this.tmdb('tvInfo', query)]
showCredits(identifier) {
const query = { id: identifier };
const cacheKey = `tmdb/${this.cacheTags.showCredits}:${identifier}`;
if (credits) {
requests.push(this.tmdb('tvCredits', query))
}
return this.getFromCacheOrFetchFromTmdb(cacheKey, "tvCredits", query)
.then(credits => this.cache.set(cacheKey, credits, this.defaultTTL))
.then(credits => Credits.convertFromTmdbResponse(credits));
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => Promise.all(requests))
.catch(() => { throw new Error('Could not find a show with that id.'); })
.then(([shows, credits]) => this.cache.set(cacheKey, [shows, credits]))
.then(([shows, credits]) => convertTmdbToShow(shows, credits))
}
/**
@@ -147,32 +123,27 @@ class TMDB {
*/
personInfo(identifier) {
const query = { id: identifier };
const cacheKey = `tmdb/${this.cacheTags.personInfo}:${identifier}`;
const cacheKey = `${this.cacheTags.personInfo}:${identifier}`;
return this.getFromCacheOrFetchFromTmdb(cacheKey, "personInfo", query)
.then(person => this.cache.set(cacheKey, person, this.defaultTTL))
.then(person => Person.convertFromTmdbResponse(person));
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => Promise.all([this.tmdb('personInfo', query), this.tmdb('personCombinedCredits', query)]))
.catch(() => { throw new Error('Could not find a person with that id.'); })
.then(([person, cast]) => this.cache.set(cacheKey, [person, cast]))
.then(([person, cast]) => convertTmdbToPerson(person, cast))
.catch(err => new Error('Unable to convert result to person', err))
}
personCredits(identifier) {
const query = { id: identifier };
const cacheKey = `tmdb/${this.cacheTags.personCredits}:${identifier}`;
return this.getFromCacheOrFetchFromTmdb(
cacheKey,
"personCombinedCredits",
query
)
.then(credits => this.cache.set(cacheKey, credits, this.defaultTTL))
.then(credits => Credits.convertFromTmdbResponse(credits));
}
multiSearch(search_query, page = 1, include_adult = true) {
const query = { query: search_query, page, include_adult };
const cacheKey = `tmdb/${this.cacheTags.multiSearch}:${page}:${search_query}:${include_adult}`;
return this.getFromCacheOrFetchFromTmdb(cacheKey, "searchMulti", query)
.then(response => this.cache.set(cacheKey, response, this.defaultTTL))
multiSearch(search_query, page=1) {
const query = { query: search_query, page: page };
const cacheKey = `${this.cacheTags.multiSearch}:${page}:${search_query}`;
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => this.tmdb('searchMulti', query))
.catch(() => { throw new Error('Could not complete search to tmdb'); })
.then(response => this.cache.set(cacheKey, response))
.then(response => this.mapResults(response));
}
@@ -182,13 +153,17 @@ class TMDB {
* @param {Number} page representing pagination of results
* @returns {Promise} dict with query results, current page and total_pages
*/
movieSearch(search_query, page = 1, include_adult = true) {
const tmdbquery = { query: search_query, page, include_adult };
const cacheKey = `tmdb/${this.cacheTags.movieSearch}:${page}:${search_query}:${include_adult}`;
movieSearch(query, page=1) {
const tmdbquery = { query: query, page: page };
const cacheKey = `${this.cacheTags.movieSearch}:${page}:${query}`;
return this.getFromCacheOrFetchFromTmdb(cacheKey, "searchMovie", tmdbquery)
.then(response => this.cache.set(cacheKey, response, this.defaultTTL))
.then(response => this.mapResults(response, "movie"));
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => this.tmdb('searchMovie', tmdbquery))
.catch(() => { throw new Error('Could not complete movie search to tmdb'); })
.then(response => this.cache.set(cacheKey, response))
.then(response => this.mapAndCreateResponse(response, convertTmdbToMovie))
.catch((error) => { console.log(error); throw new Error('Could not parse movie search result') })
}
/**
@@ -197,13 +172,16 @@ class TMDB {
* @param {Number} page representing pagination of results
* @returns {Promise} dict with query results, current page and total_pages
*/
showSearch(search_query, page = 1, include_adult = true) {
const tmdbquery = { query: search_query, page, include_adult };
const cacheKey = `tmdb/${this.cacheTags.showSearch}:${page}:${search_query}:${include_adult}`;
return this.getFromCacheOrFetchFromTmdb(cacheKey, "searchTv", tmdbquery)
.then(response => this.cache.set(cacheKey, response, this.defaultTTL))
.then(response => this.mapResults(response, "show"));
showSearch(query, page=1) {
const tmdbquery = { query: query, page: page };
const cacheKey = `${this.cacheTags.showSearch}:${page}:${query}`;
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => this.tmdb('searchTv', tmdbquery))
.catch(() => { throw new Error('Could not complete show search to tmdb'); })
.then(response => this.cache.set(cacheKey, response))
.then(response => this.mapAndCreateResponse(response, convertTmdbToShow))
.catch((error) => { console.log(error); throw new Error('Could not parse show search result') })
}
/**
@@ -212,31 +190,79 @@ class TMDB {
* @param {Number} page representing pagination of results
* @returns {Promise} dict with query results, current page and total_pages
*/
personSearch(search_query, page = 1, include_adult = true) {
const tmdbquery = { query: search_query, page, include_adult };
const cacheKey = `tmdb/${this.cacheTags.personSearch}:${page}:${search_query}:${include_adult}`;
return this.getFromCacheOrFetchFromTmdb(cacheKey, "searchPerson", tmdbquery)
.then(response => this.cache.set(cacheKey, response, this.defaultTTL))
.then(response => this.mapResults(response, "person"));
personSearch(query, page=1) {
const tmdbquery = { query: query, page: page };
const cacheKey = `${this.cacheTags.personSearch}:${page}:${query}`;
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => this.tmdb('searchPerson', tmdbquery))
.catch(() => { throw new Error('Could not complete person search to tmdb'); })
.then(response => this.cache.set(cacheKey, response))
.then(response => this.mapAndCreateResponse(response, convertTmdbToPerson))
.catch((error) => { console.log(error); throw new Error('Could not parse person search result') })
}
mapAndCreateResponse(response, resultConvertFunction) {
// console.log(response)
return {
results: response.results.map(resultConvertFunction),
page: response.page,
total_results: response.total_results,
total_pages: response.total_pages
}
}
movieList(listname, page = 1) {
const query = { page: page };
const cacheKey = `tmdb/${this.cacheTags[listname]}:${page}`;
return this.getFromCacheOrFetchFromTmdb(cacheKey, listname, query)
.then(response => this.cache.set(cacheKey, response, this.defaultTTL))
.then(response => this.mapResults(response, "movie"));
const cacheKey = `${this.cacheTags[listname]}:${page}`;
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => this.tmdb(listname, query))
.catch(() => { throw new Error('Unable to get movie list from tmdb')})
.then(response => this.cache.set(cacheKey, response))
.then(response => this.mapAndCreateResponse(response, convertTmdbToMovie));
}
showList(listname, page = 1) {
const query = { page: page };
const cacheKey = `tmdb/${this.cacheTags[listname]}:${page}`;
const cacheKey = `${this.cacheTags[listname]}:${page}`;
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => this.tmdb(listname, query))
.catch(() => { throw new Error('Unable to get show list from tmdb')})
.then(response => this.cache.set(cacheKey, response))
.then(response => this.mapAndCreateResponse(response, convertTmdbToShow));
}
return this.getFromCacheOrFetchFromTmdb(cacheKey, listName, query)
.then(response => this.cache.set(cacheKey, response, this.defaultTTL))
.then(response => this.mapResults(response, "show"));
/**
* Fetches a given list from tmdb.
* @param {String} listName Name of list
* @param {String} type filter results by type (default movie)
* @param {Number} page representing pagination of results
* @returns {Promise} dict with query results, current page and total_pages
*/
listSearch(listName, type = 'movie', page = '1') {
const query = { page: page };
console.log(query);
const cacheKey = `${this.cacheTags[listName]}:${type}:${page}`;
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => this.tmdb(TMDB_METHODS[listName][type], query))
.catch(() => { throw new Error('Error fetching list from tmdb.'); })
.then(response => this.cache.set(cacheKey, response))
.then(response => this.mapResults(response, type));
}
popular(type='movie', page=1) {
const query = { type: type, page: page };
const cacheKey = `${this.cacheTags.popular}:${type}:${page}`;
return Promise.resolve()
.then(() => this.cache.get(cacheKey))
.catch(() => this.tmdb('miscPopularMovies', query))
.catch((e) => { throw new Error(`Error fetching popular list of type ${type} : ${e}`) })
.then(response => this.cache.set(cacheKey, response))
.then(response => this.mapResults(response, type));
}
/**
@@ -245,26 +271,23 @@ class TMDB {
* @param {String} The type declared in listSearch.
* @returns {Promise} dict with tmdb results, mapped as movie/show objects.
*/
mapResults(response, type = undefined) {
let results = response.results.map(result => {
if (type === "movie" || result.media_type === "movie") {
const movie = Movie.convertFromTmdbResponse(result);
return movie.createJsonResponse();
} else if (type === "show" || result.media_type === "tv") {
const show = Show.convertFromTmdbResponse(result);
return show.createJsonResponse();
} else if (type === "person" || result.media_type === "person") {
const person = Person.convertFromTmdbResponse(result);
return person.createJsonResponse();
mapResults(response, _) {
let results = response.results.map((result) => {
if (result.media_type === 'movie') {
return convertTmdbToMovie(result);
} else if (result.media_type === 'tv') {
return convertTmdbToShow(result);
} else if (result.media_type === 'person') {
return convertTmdbToPerson(result);
}
});
})
return {
results: results,
page: response.page,
total_results: response.total_results,
total_pages: response.total_pages
};
}
}
/**
@@ -273,22 +296,22 @@ class TMDB {
* @param {Object} argument argument to function being called
* @returns {Promise} succeeds if callback succeeds
*/
tmdb(method, argument) {
return new Promise((resolve, reject) => {
const callback = (error, reponse) => {
if (error) {
return reject(error);
}
resolve(reponse);
};
tmdb(method, argument) {
return new Promise((resolve, reject) => {
const callback = (error, reponse) => {
if (error) {
return reject(error);
}
resolve(reponse);
};
if (!argument) {
this.tmdbLibrary[method](callback);
} else {
this.tmdbLibrary[method](argument, callback);
}
});
}
if (!argument) {
this.tmdbLibrary[method](callback);
} else {
this.tmdbLibrary[method](argument, callback);
}
});
}
}
module.exports = TMDB;

7
seasoned_api/src/tmdb/tmdb.ts
View File

@@ -1,7 +0,0 @@
import { Movie } from './types'
Movie('str', 123)
module.exports = TMDB;

7
seasoned_api/src/tmdb/types.js
View File

@@ -1,7 +0,0 @@
const Movie = require('./types/movie.js')
const Show = require('./types/show.js')
const Person = require('./types/person.js')
const Credits = require('./types/credits.js')
const ReleaseDates = require('./types/releaseDates.js')
module.exports = { Movie, Show, Person, Credits, ReleaseDates }

64
seasoned_api/src/tmdb/types.ts
View File

@@ -1,64 +0,0 @@
interface Movie {
adult: boolean;
backdrop: string;
genres: Genre[];
id: number;
imdb_id: number;
overview: string;
popularity: number;
poster: string;
release_date: Date;
rank: number;
runtime: number;
status: string;
tagline: string;
title: string;
vote_count: number;
}
interface Show {
adult: boolean;
backdrop: string;
episodes: number;
genres: Genre[];
id: number;
imdb_id: number;
overview: string;
popularity: number;
poster: string;
rank: number;
runtime: number;
seasons: number;
status: string;
tagline: string;
title: string;
vote_count: number;
}
interface Person {
birthday: Date;
deathday: Date;
id: number;
known_for: string;
name: string;
poster: string;
}
interface SearchResult {
adult: boolean;
backdrop_path: string;
id: number;
original_title: string;
release_date: Date;
poster_path: string;
popularity: number;
vote_average: number;
vote_counte: number;
}
interface Genre {
id: number;
name: string;
}
export { Movie, Show, Person, Genre }

113
seasoned_api/src/tmdb/types/credits.js
View File

@@ -1,113 +0,0 @@
import Movie from "./movie";
import Show from "./show";
class Credits {
constructor(id, cast = [], crew = []) {
this.id = id;
this.cast = cast;
this.crew = crew;
this.type = "credits";
}
static convertFromTmdbResponse(response) {
const { id, cast, crew } = response;
const allCast = cast.map(cast => {
if (cast["media_type"]) {
if (cast.media_type === "movie") {
return CreditedMovie.convertFromTmdbResponse(cast);
} else if (cast.media_type === "tv") {
return CreditedShow.convertFromTmdbResponse(cast);
}
}
return new CastMember(
cast.character,
cast.gender,
cast.id,
cast.name,
cast.profile_path
);
});
const allCrew = crew.map(crew => {
if (cast["media_type"]) {
if (cast.media_type === "movie") {
return CreditedMovie.convertFromTmdbResponse(cast);
} else if (cast.media_type === "tv") {
return CreditedShow.convertFromTmdbResponse(cast);
}
}
return new CrewMember(
crew.department,
crew.gender,
crew.id,
crew.job,
crew.name,
crew.profile_path
);
});
return new Credits(id, allCast, allCrew);
}
createJsonResponse() {
return {
id: this.id,
cast: this.cast.map(cast => cast.createJsonResponse()),
crew: this.crew.map(crew => crew.createJsonResponse())
};
}
}
class CastMember {
constructor(character, gender, id, name, profile_path) {
this.character = character;
this.gender = gender;
this.id = id;
this.name = name;
this.profile_path = profile_path;
this.type = "person";
}
createJsonResponse() {
return {
character: this.character,
gender: this.gender,
id: this.id,
name: this.name,
profile_path: this.profile_path,
type: this.type
};
}
}
class CrewMember {
constructor(department, gender, id, job, name, profile_path) {
this.department = department;
this.gender = gender;
this.id = id;
this.job = job;
this.name = name;
this.profile_path = profile_path;
this.type = "person";
}
createJsonResponse() {
return {
department: this.department,
gender: this.gender,
id: this.id,
job: this.job,
name: this.name,
profile_path: this.profile_path,
type: this.type
};
}
}
class CreditedMovie extends Movie {}
class CreditedShow extends Show {}
module.exports = Credits;

50
seasoned_api/src/tmdb/types/movie.js
View File

@@ -1,62 +1,20 @@
class Movie {
constructor(id, title, year=undefined, overview=undefined, poster=undefined, backdrop=undefined,
releaseDate=undefined, rating=undefined, genres=undefined, productionStatus=undefined,
tagline=undefined, runtime=undefined, imdb_id=undefined, popularity=undefined) {
constructor(id, title, year=null, overview=null, poster=null, backdrop=null, rank=null, genres=null, status=null,
tagline=null, runtime=null, imdb_id=null) {
this.id = id;
this.title = title;
this.year = year;
this.overview = overview;
this.poster = poster;
this.backdrop = backdrop;
this.releaseDate = releaseDate;
this.rating = rating;
this.rank = rank;
this.genres = genres;
this.productionStatus = productionStatus;
this.status = status;
this.tagline = tagline;
this.runtime = runtime;
this.imdb_id = imdb_id;
this.popularity = popularity;
this.type = 'movie';
}
static convertFromTmdbResponse(response) {
const { id, title, release_date, overview, poster_path, backdrop_path, vote_average, genres, status,
tagline, runtime, imdb_id, popularity } = response;
const releaseDate = new Date(release_date);
const year = releaseDate.getFullYear();
const genreNames = genres ? genres.map(g => g.name) : undefined
return new Movie(id, title, year, overview, poster_path, backdrop_path, releaseDate, vote_average, genreNames, status,
tagline, runtime, imdb_id, popularity)
}
static convertFromPlexResponse(response) {
// console.log('response', response)
const { title, year, rating, tagline, summary } = response;
const _ = undefined
return new Movie(null, title, year, summary, _, _, _, rating, _, _, tagline)
}
createJsonResponse() {
return {
id: this.id,
title: this.title,
year: this.year,
overview: this.overview,
poster: this.poster,
backdrop: this.backdrop,
release_date: this.releaseDate,
rating: this.rating,
genres: this.genres,
production_status: this.productionStatus,
tagline: this.tagline,
runtime: this.runtime,
imdb_id: this.imdb_id,
type: this.type
}
}
}
module.exports = Movie;

65
seasoned_api/src/tmdb/types/person.js
View File

@@ -1,69 +1,12 @@
class Person {
constructor(
id,
name,
poster = undefined,
birthday = undefined,
deathday = undefined,
adult = undefined,
placeOfBirth = undefined,
biography = undefined,
knownForDepartment = undefined
) {
class Person {
constructor(id, name, poster=null, birthday=null, deathday=null, known_for=null) {
this.id = id;
this.name = name;
this.poster = poster;
this.birthday = birthday;
this.deathday = deathday;
this.adult = adult;
this.placeOfBirth = placeOfBirth;
this.biography = biography;
this.knownForDepartment = knownForDepartment;
this.type = "person";
}
static convertFromTmdbResponse(response) {
const {
id,
name,
profile_path,
birthday,
deathday,
adult,
place_of_birth,
biography,
known_for_department
} = response;
const birthDay = new Date(birthday);
const deathDay = deathday ? new Date(deathday) : null;
return new Person(
id,
name,
profile_path,
birthDay,
deathDay,
adult,
place_of_birth,
biography,
known_for_department
);
}
createJsonResponse() {
return {
id: this.id,
name: this.name,
poster: this.poster,
birthday: this.birthday,
deathday: this.deathday,
place_of_birth: this.placeOfBirth,
biography: this.biography,
known_for_department: this.knownForDepartment,
adult: this.adult,
type: this.type
};
this.known_for = known_for;
this.type = 'person';
}
}

78
seasoned_api/src/tmdb/types/releaseDates.js
View File

@@ -1,78 +0,0 @@
class ReleaseDates {
constructor(id, releases) {
this.id = id;
this.releases = releases;
}
static convertFromTmdbResponse(response) {
const { id, results } = response;
const releases = results.map(countryRelease =>
new Release(
countryRelease.iso_3166_1,
countryRelease.release_dates.map(rd => new ReleaseDate(rd.certification, rd.iso_639_1, rd.release_date, rd.type, rd.note))
))
return new ReleaseDates(id, releases)
}
createJsonResponse() {
return {
id: this.id,
results: this.releases.map(release => release.createJsonResponse())
}
}
}
class Release {
constructor(country, releaseDates) {
this.country = country;
this.releaseDates = releaseDates;
}
createJsonResponse() {
return {
country: this.country,
release_dates: this.releaseDates.map(releaseDate => releaseDate.createJsonResponse())
}
}
}
class ReleaseDate {
constructor(certification, language, releaseDate, type, note) {
this.certification = certification;
this.language = language;
this.releaseDate = releaseDate;
this.type = this.releaseTypeLookup(type);
this.note = note;
}
releaseTypeLookup(releaseTypeKey) {
const releaseTypeEnum = {
1: 'Premier',
2: 'Limited theatrical',
3: 'Theatrical',
4: 'Digital',
5: 'Physical',
6: 'TV'
}
if (releaseTypeKey <= Object.keys(releaseTypeEnum).length) {
return releaseTypeEnum[releaseTypeKey]
} else {
// TODO log | Release type not defined, does this need updating?
return null
}
}
createJsonResponse() {
return {
certification: this.certification,
language: this.language,
release_date: this.releaseDate,
type: this.type,
note: this.note
}
}
}
module.exports = ReleaseDates;

42
seasoned_api/src/tmdb/types/show.js
View File

@@ -1,50 +1,20 @@
class Show {
constructor(id, title, year=undefined, overview=undefined, poster=undefined, backdrop=undefined,
seasons=undefined, episodes=undefined, rank=undefined, genres=undefined, status=undefined,
runtime=undefined) {
constructor(id, title, year=null, seasons=null, episodes=null, overview=null, rank=null, genres=null,
poster=null, backdrop=null, status=null, runtime=null) {
this.id = id;
this.title = title;
this.year = year;
this.overview = overview;
this.poster = poster;
this.backdrop = backdrop;
this.seasons = seasons;
this.episodes = episodes;
this.overview = overview;
this.rank = rank;
this.genres = genres;
this.productionStatus = status;
this.poster = poster;
this.backdrop = backdrop;
this.status = status;
this.runtime = runtime;
this.type = 'show';
}
static convertFromTmdbResponse(response) {
const { id, name, first_air_date, overview, poster_path, backdrop_path, number_of_seasons, number_of_episodes,
rank, genres, status, episode_run_time, popularity } = response;
const year = new Date(first_air_date).getFullYear()
const genreNames = genres ? genres.map(g => g.name) : undefined
return new Show(id, name, year, overview, poster_path, backdrop_path, number_of_seasons, number_of_episodes,
rank, genreNames, status, episode_run_time, popularity)
}
createJsonResponse() {
return {
id: this.id,
title: this.title,
year: this.year,
overview: this.overview,
poster: this.poster,
backdrop: this.backdrop,
seasons: this.seasons,
episodes: this.episodes,
rank: this.rank,
genres: this.genres,
production_status: this.productionStatus,
runtime: this.runtime,
type: this.type
}
}
}
module.exports = Show;

52
seasoned_api/src/user/token.js
View File

@@ -1,41 +1,37 @@
const User = require("src/user/user");
const jwt = require("jsonwebtoken");
const User = require('src/user/user');
const jwt = require('jsonwebtoken');
class Token {
constructor(user, admin = false, settings = null) {
this.user = user;
this.admin = admin;
this.settings = settings;
}
constructor(user) {
this.user = user;
}
/**
* Generate a new token.
* @param {String} secret a cipher of the token
* @returns {String}
*/
toString(secret) {
const { user, admin, settings } = this;
/**
* Generate a new token.
* @param {String} secret a cipher of the token
* @returns {String}
*/
toString(secret) {
return jwt.sign({ username: this.user.username }, secret);
}
let data = { username: user.username, settings };
if (admin) data["admin"] = admin;
return jwt.sign(data, secret, { expiresIn: "90d" });
}
/**
/**
* Decode a token.
* @param {Token} jwtToken an encrypted token
* @param {String} secret a cipher of the token
* @returns {Token}
*/
static fromString(jwtToken, secret) {
const token = jwt.verify(jwtToken, secret, { clockTolerance: 10000 });
if (token.username == null) throw new Error("Malformed token");
static fromString(jwtToken, secret) {
let username = null;
const { username, admin, settings } = token;
const user = new User(username);
return new Token(user, admin, settings);
}
try {
username = jwt.verify(jwtToken, secret).username;
} catch (error) {
throw new Error('The token is invalid.');
}
const user = new User(username);
return new Token(user);
}
}
module.exports = Token;

276
seasoned_api/src/user/userRepository.js
View File

@@ -1,256 +1,64 @@
const assert = require("assert");
const establishedDatabase = require("src/database/database");
const assert = require('assert');
const establishedDatabase = require('src/database/database');
class UserRepository {
constructor(database) {
this.database = database || establishedDatabase;
this.queries = {
read: "select * from user where lower(user_name) = lower(?)",
create: "insert into user (user_name) values (?)",
change: "update user set password = ? where user_name = ?",
retrieveHash: "select * from user where user_name = ?",
getAdminStateByUser: "select admin from user where user_name = ?",
link: "update settings set plex_userid = ? where user_name = ?",
unlink: "update settings set plex_userid = null where user_name = ?",
createSettings: "insert into settings (user_name) values (?)",
updateSettings:
"update settings set user_name = ?, dark_mode = ?, emoji = ?",
getSettings: "select * from settings where user_name = ?"
};
}
constructor(database) {
this.database = database || establishedDatabase;
this.queries = {
read: 'select * from user where lower(user_name) = lower(?)',
create: 'insert into user (user_name) values (?)',
change: 'update user set password = ? where user_name = ?',
retrieveHash: 'select * from user where user_name = ?',
getAdminStateByUser: 'select admin from user where user_name = ?'
};
}
/**
/**
* Create a user in a database.
* @param {User} user the user you want to create
* @returns {Promise}
*/
create(user) {
return this.database
.get(this.queries.read, user.username)
.then(() => this.database.run(this.queries.create, user.username))
.catch(error => {
if (
error.name === "AssertionError" ||
error.message.endsWith("user_name")
) {
throw new Error("That username is already registered");
}
throw Error(error);
});
}
create(user) {
return Promise.resolve()
.then(() => this.database.get(this.queries.read, user.username))
.then(() => this.database.run(this.queries.create, user.username))
.catch((error) => {
if (error.name === 'AssertionError' || error.message.endsWith('user_name')) {
throw new Error('That username is already registered');
}
});
}
/**
/**
* Retrieve a password from a database.
* @param {User} user the user you want to retrieve the password
* @returns {Promise}
*/
retrieveHash(user) {
return this.database
.get(this.queries.retrieveHash, user.username)
.then(row => {
assert(row, "The user does not exist.");
return row.password;
})
.catch(err => {
console.log(error);
throw new Error("Unable to find your user.");
});
}
retrieveHash(user) {
return Promise.resolve()
.then(() => this.database.get(this.queries.retrieveHash, user.username))
.then((row) => {
assert(row, 'The user does not exist.');
return row.password;
})
.catch((err) => { console.log(error); throw new Error('Unable to find your user.'); });
}
/**
/**
* Change a user's password in a database.
* @param {User} user the user you want to create
* @param {String} password the new password you want to change
* @returns {Promise}
*/
changePassword(user, password) {
return this.database.run(this.queries.change, [password, user.username]);
}
changePassword(user, password) {
return Promise.resolve(this.database.run(this.queries.change, [password, user.username]));
}
/**
* Link plex userid with seasoned user
* @param {String} username the user you want to lunk plex userid with
* @param {Number} plexUserID plex unique id
* @returns {Promsie}
*/
linkPlexUserId(username, plexUserID) {
return new Promise((resolve, reject) => {
this.database
.run(this.queries.link, [plexUserID, username])
.then(row => resolve(row))
.catch(error => {
// TODO log this unknown db error
console.error("db error", error);
reject({
status: 500,
message:
"An unexpected error occured while linking plex and seasoned accounts",
source: "seasoned database"
});
});
});
}
/**
* Unlink plex userid with seasoned user
* @param {User} user the user you want to lunk plex userid with
* @returns {Promsie}
*/
unlinkPlexUserId(username) {
return new Promise((resolve, reject) => {
this.database
.run(this.queries.unlink, username)
.then(row => resolve(row))
.catch(error => {
// TODO log this unknown db error
console.log("db error", error);
reject({
status: 500,
message:
"An unexpected error occured while unlinking plex and seasoned accounts",
source: "seasoned database"
});
});
});
}
/**
* Check if the user has boolean flag set for admin in database
* @param {User} user object
* @returns {Promsie}
*/
checkAdmin(user) {
return this.database
.get(this.queries.getAdminStateByUser, user.username)
.then(row => row.admin);
}
/**
* Get settings for user matching string username
* @param {String} username
* @returns {Promsie}
*/
getSettings(username) {
return new Promise((resolve, reject) => {
this.database
.get(this.queries.getSettings, username)
.then(async row => {
if (row == null) {
console.debug(
`settings do not exist for user: ${username}. Creating settings entry.`
);
const userExistsWithUsername = await this.database.get(
"select * from user where user_name is ?",
username
);
if (userExistsWithUsername !== undefined) {
try {
resolve(this.dbCreateSettings(username));
} catch (error) {
reject(error);
}
} else {
reject({
status: 404,
message: "User not found, no settings to get"
});
}
}
resolve(row);
})
.catch(error => {
console.error(
"Unexpected error occured while fetching settings for your account. Error:",
error
);
reject({
status: 500,
message:
"An unexpected error occured while fetching settings for your account",
source: "seasoned database"
});
});
});
}
/**
* Update settings values for user matching string username
* @param {String} username
* @param {String} dark_mode
* @param {String} emoji
* @returns {Promsie}
*/
updateSettings(username, dark_mode = undefined, emoji = undefined) {
const settings = this.getSettings(username);
dark_mode = dark_mode !== undefined ? dark_mode : settings.dark_mode;
emoji = emoji !== undefined ? emoji : settings.emoji;
return this.dbUpdateSettings(username, dark_mode, emoji).catch(error => {
if (error.status && error.message) {
return error;
}
return {
status: 500,
message:
"An unexpected error occured while updating settings for your account"
};
});
}
/**
* Helper function for creating settings in the database
* @param {String} username
* @returns {Promsie}
*/
dbCreateSettings(username) {
return this.database
.run(this.queries.createSettings, username)
.then(() => this.database.get(this.queries.getSettings, username))
.catch(error =>
rejectUnexpectedDatabaseError(
"Unexpected error occured while creating settings",
503,
error
)
);
}
/**
* Helper function for updating settings in the database
* @param {String} username
* @returns {Promsie}
*/
dbUpdateSettings(username, dark_mode, emoji) {
return new Promise((resolve, reject) =>
this.database
.run(this.queries.updateSettings, [username, dark_mode, emoji])
.then(row => resolve(row))
);
}
checkAdmin(user) {
return this.database.get(this.queries.getAdminStateByUser, user.username).then((row) => {
return row.admin;
});
}
}
const rejectUnexpectedDatabaseError = (
message,
status,
error,
reject = null
) => {
console.error(error);
const body = {
status,
message,
source: "seasoned database"
};
if (reject == null) {
return new Promise((resolve, reject) => reject(body));
}
reject(body);
};
module.exports = UserRepository;

88
seasoned_api/src/user/userSecurity.js
View File

@@ -1,75 +1,73 @@
const bcrypt = require("bcrypt");
const UserRepository = require("src/user/userRepository");
const bcrypt = require('bcrypt-nodejs');
const UserRepository = require('src/user/userRepository');
class UserSecurity {
constructor(database) {
this.userRepository = new UserRepository(database);
}
constructor(database) {
this.userRepository = new UserRepository(database);
}
/**
/**
* Create a new user in PlanFlix.
* @param {User} user the new user you want to create
* @param {String} clearPassword a password of the user
* @returns {Promise}
*/
createNewUser(user, clearPassword) {
if (user.username.trim() === "") {
throw new Error("The username is empty.");
} else if (clearPassword.trim() === "") {
throw new Error("The password is empty.");
} else {
return this.userRepository
.create(user)
.then(() => UserSecurity.hashPassword(clearPassword))
.then(hash => this.userRepository.changePassword(user, hash));
}
}
createNewUser(user, clearPassword) {
if (user.username.trim() === '') {
throw new Error('The username is empty.');
} else if (clearPassword.trim() === '') {
throw new Error('The password is empty.');
} else {
return Promise.resolve()
.then(() => this.userRepository.create(user))
.then(() => UserSecurity.hashPassword(clearPassword))
.then(hash => this.userRepository.changePassword(user, hash));
}
}
/**
/**
* Login into PlanFlix.
* @param {User} user the user you want to login
* @param {String} clearPassword the user's password
* @returns {Promise}
*/
login(user, clearPassword) {
return this.userRepository
.retrieveHash(user)
.then(hash => UserSecurity.compareHashes(hash, clearPassword))
.catch(() => {
throw new Error("Incorrect username or password.");
});
}
login(user, clearPassword) {
return Promise.resolve()
.then(() => this.userRepository.retrieveHash(user))
.then(hash => UserSecurity.compareHashes(hash, clearPassword))
.catch(() => { throw new Error('Wrong username or password.'); });
}
/**
/**
* Compare between a password and a hash password from database.
* @param {String} hash the hash password from database
* @param {String} clearPassword the user's password
* @returns {Promise}
*/
static compareHashes(hash, clearPassword) {
return new Promise((resolve, reject) => {
bcrypt.compare(clearPassword, hash, (error, match) => {
if (match) resolve(true);
reject(false);
static compareHashes(hash, clearPassword) {
return new Promise((resolve, reject) => {
bcrypt.compare(clearPassword, hash, (error, matches) => {
if (matches === true) {
resolve();
} else {
reject();
}
});
});
});
}
}
/**
/**
* Hashes a password.
* @param {String} clearPassword the user's password
* @returns {Promise}
*/
static hashPassword(clearPassword) {
return new Promise(resolve => {
const saltRounds = 10;
bcrypt.hash(clearPassword, saltRounds, (error, hash) => {
if (error) reject(error);
resolve(hash);
static hashPassword(clearPassword) {
return new Promise((resolve) => {
bcrypt.hash(clearPassword, null, null, (error, hash) => {
resolve(hash);
});
});
});
}
}
}
module.exports = UserSecurity;

244
seasoned_api/src/webserver/app.js
View File

@@ -1,239 +1,137 @@
const express = require("express");
const Raven = require("raven");
const cookieParser = require("cookie-parser");
const bodyParser = require("body-parser");
const express = require('express');
const Raven = require('raven');
const bodyParser = require('body-parser');
const tokenToUser = require('./middleware/tokenToUser');
const mustBeAuthenticated = require('./middleware/mustBeAuthenticated');
const mustBeAdmin = require('./middleware/mustBeAdmin');
const configuration = require('src/config/configuration').getInstance();
const configuration = require("src/config/configuration").getInstance();
const reqTokenToUser = require("./middleware/reqTokenToUser");
const mustBeAuthenticated = require("./middleware/mustBeAuthenticated");
const mustBeAdmin = require("./middleware/mustBeAdmin");
const mustHaveAccountLinkedToPlex = require("./middleware/mustHaveAccountLinkedToPlex");
const listController = require("./controllers/list/listController");
const tautulli = require("./controllers/user/viewHistory.js");
const SettingsController = require("./controllers/user/settings");
const AuthenticatePlexAccountController = require("./controllers/user/authenticatePlexAccount");
const listController = require('./controllers/list/listController');
// TODO: Have our raven router check if there is a value, if not don't enable raven.
Raven.config(configuration.get("raven", "DSN")).install();
Raven.config(configuration.get('raven', 'DSN')).install();
const app = express(); // define our app using express
app.use(Raven.requestHandler());
app.use(bodyParser.json());
app.use(cookieParser());
const router = express.Router();
const allowedOrigins = configuration.get("webserver", "origins");
const allowedOrigins = ['https://kevinmidboe.com', 'http://localhost:8080'];
// TODO: All JSON handling in a single router
// router.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
/* Check header and cookie for authentication and set req.loggedInUser */
router.use(reqTokenToUser);
/* Decode the Authorization header if provided */
router.use(tokenToUser);
// TODO: Should have a separate middleware/router for handling headers.
router.use((req, res, next) => {
// TODO add logging of all incoming
// const origin = req.headers.origin;
// if (allowedOrigins.indexOf(origin) > -1) {
// res.setHeader("Access-Control-Allow-Origin", origin);
// }
// TODO add logging of all incoming
console.log('Request: ', req.originalUrl);
res.header(
"Access-Control-Allow-Headers",
"Content-Type, Authorization, loggedinuser, set-cookie"
);
const origin = req.headers.origin;
if (allowedOrigins.indexOf(origin) > -1) {
res.setHeader('Access-Control-Allow-Origin', origin);
}
res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, loggedinuser');
res.header('Access-Control-Allow-Methods', 'POST, GET, PUT');
res.header("Access-Control-Allow-Credentials", "true");
res.header("Access-Control-Allow-Methods", "POST, GET, PUT, OPTIONS");
next();
next();
});
router.get("/", (req, res) => {
res.send("welcome to seasoned api");
router.get('/', function mainHandler(req, res) {
throw new Error('Broke!');
});
app.use(Raven.errorHandler());
app.use((err, req, res, next) => {
res.statusCode = 500;
res.end(res.sentry + "\n");
app.use(function onError(err, req, res, next) {
res.statusCode = 500;
res.end(res.sentry + '\n');
});
/**
* User
*/
router.post("/v1/user", require("./controllers/user/register.js"));
router.post("/v1/user/login", require("./controllers/user/login.js"));
router.post("/v1/user/logout", require("./controllers/user/logout.js"));
router.get(
"/v1/user/settings",
mustBeAuthenticated,
SettingsController.getSettingsController
);
router.put(
"/v1/user/settings",
mustBeAuthenticated,
SettingsController.updateSettingsController
);
router.get(
"/v1/user/search_history",
mustBeAuthenticated,
require("./controllers/user/searchHistory.js")
);
router.get(
"/v1/user/requests",
mustBeAuthenticated,
require("./controllers/user/requests.js")
);
router.post(
"/v1/user/link_plex",
mustBeAuthenticated,
AuthenticatePlexAccountController.link
);
router.post(
"/v1/user/unlink_plex",
mustBeAuthenticated,
AuthenticatePlexAccountController.unlink
);
router.get(
"/v1/user/view_history",
mustHaveAccountLinkedToPlex,
tautulli.userViewHistoryController
);
router.get(
"/v1/user/watch_time",
mustHaveAccountLinkedToPlex,
tautulli.watchTimeStatsController
);
router.get(
"/v1/user/plays_by_day",
mustHaveAccountLinkedToPlex,
tautulli.getPlaysByDaysController
);
router.get(
"/v1/user/plays_by_dayofweek",
mustHaveAccountLinkedToPlex,
tautulli.getPlaysByDayOfWeekController
);
router.post('/v1/user', require('./controllers/user/register.js'));
router.post('/v1/user/login', require('./controllers/user/login.js'));
router.get('/v1/user/history', mustBeAuthenticated, require('./controllers/user/history.js'));
router.get('/v1/user/requests', mustBeAuthenticated, require('./controllers/user/requests.js'));
/**
* Seasoned
*/
router.get("/v1/seasoned/all", require("./controllers/seasoned/readStrays.js"));
router.get(
"/v1/seasoned/:strayId",
require("./controllers/seasoned/strayById.js")
);
router.post(
"/v1/seasoned/verify/:strayId",
require("./controllers/seasoned/verifyStray.js")
);
router.get('/v1/seasoned/all', require('./controllers/seasoned/readStrays.js'));
router.get('/v1/seasoned/:strayId', require('./controllers/seasoned/strayById.js'));
router.post('/v1/seasoned/verify/:strayId', require('./controllers/seasoned/verifyStray.js'));
router.get("/v2/search/", require("./controllers/search/multiSearch.js"));
router.get("/v2/search/movie", require("./controllers/search/movieSearch.js"));
router.get("/v2/search/show", require("./controllers/search/showSearch.js"));
router.get(
"/v2/search/person",
require("./controllers/search/personSearch.js")
);
router.get('/v2/search/', require('./controllers/search/multiSearch.js'));
router.get('/v2/search/movie', require('./controllers/search/movieSearch.js'));
router.get('/v2/search/show', require('./controllers/search/showSearch.js'));
router.get('/v2/search/person', require('./controllers/search/personSearch.js'));
router.get("/v2/movie/now_playing", listController.nowPlayingMovies);
router.get("/v2/movie/popular", listController.popularMovies);
router.get("/v2/movie/top_rated", listController.topRatedMovies);
router.get("/v2/movie/upcoming", listController.upcomingMovies);
router.get("/v2/movie/:id/credits", require("./controllers/movie/credits.js"));
router.get(
"/v2/movie/:id/release_dates",
require("./controllers/movie/releaseDates.js")
);
router.get("/v2/movie/:id", require("./controllers/movie/info.js"));
router.get('/v2/movie/now_playing', listController.nowPlayingMovies);
router.get('/v2/movie/popular', listController.popularMovies);
router.get('/v2/movie/top_rated', listController.topRatedMovies);
router.get('/v2/movie/upcoming', listController.upcomingMovies);
router.get("/v2/show/now_playing", listController.nowPlayingShows);
router.get("/v2/show/popular", listController.popularShows);
router.get("/v2/show/top_rated", listController.topRatedShows);
router.get("/v2/show/:id/credits", require("./controllers/show/credits.js"));
router.get("/v2/show/:id", require("./controllers/show/info.js"));
router.get(
"/v2/person/:id/credits",
require("./controllers/person/credits.js")
);
router.get("/v2/person/:id", require("./controllers/person/info.js"));
router.get('/v2/show/now_playing', listController.nowPlayingShows);
router.get('/v2/show/popular', listController.popularShows);
router.get('/v2/show/top_rated', listController.topRatedShows);
router.get('/v2/movie/:id', require('./controllers/info/movieInfo.js'));
router.get('/v2/show/:id', require('./controllers/info/showInfo.js'));
router.get('/v2/person/:id', require('./controllers/info/personInfo.js'));
/**
* Plex
*/
router.get("/v2/plex/search", require("./controllers/plex/search"));
router.get('/v2/plex/search', require('./controllers/plex/search'));
/**
* List
*/
router.get("/v1/plex/search", require("./controllers/plex/searchMedia.js"));
router.get("/v1/plex/playing", require("./controllers/plex/plexPlaying.js"));
router.get("/v1/plex/request", require("./controllers/plex/searchRequest.js"));
router.get(
"/v1/plex/request/:mediaId",
require("./controllers/plex/readRequest.js")
);
router.post(
"/v1/plex/request/:mediaId",
require("./controllers/plex/submitRequest.js")
);
router.post("/v1/plex/hook", require("./controllers/plex/hookDump.js"));
router.get(
"/v1/plex/watch-link",
mustBeAuthenticated,
require("./controllers/plex/watchDirectLink.js")
);
router.get('/v1/plex/search', require('./controllers/plex/searchMedia.js'));
router.get('/v1/plex/playing', require('./controllers/plex/plexPlaying.js'));
router.get('/v1/plex/request', require('./controllers/plex/searchRequest.js'));
router.get('/v1/plex/request/:mediaId', require('./controllers/plex/readRequest.js'));
router.post('/v1/plex/request/:mediaId', require('./controllers/plex/submitRequest.js'));
router.post('/v1/plex/hook', require('./controllers/plex/hookDump.js'));
/**
* Requests
*/
router.get("/v2/request", require("./controllers/request/fetchAllRequests.js"));
router.get("/v2/request/:id", require("./controllers/request/getRequest.js"));
router.post("/v2/request", require("./controllers/request/requestTmdbId.js"));
router.get(
"/v1/plex/requests/all",
require("./controllers/plex/fetchRequested.js")
);
router.put(
"/v1/plex/request/:requestId",
mustBeAuthenticated,
require("./controllers/plex/updateRequested.js")
);
router.get('/v2/request', require('./controllers/request/fetchAllRequests.js'));
router.get('/v2/request/:id', require('./controllers/request/getRequest.js'));
router.post('/v2/request', require('./controllers/request/requestTmdbId.js'));
router.get('/v1/plex/requests/all', require('./controllers/plex/fetchRequested.js'));
router.put('/v1/plex/request/:requestId', mustBeAuthenticated, require('./controllers/plex/updateRequested.js'));
/**
* Pirate
*/
router.get(
"/v1/pirate/search",
mustBeAuthenticated,
require("./controllers/pirate/searchTheBay.js")
);
router.post(
"/v1/pirate/add",
mustBeAuthenticated,
require("./controllers/pirate/addMagnet.js")
);
router.get('/v1/pirate/search', mustBeAuthenticated, require('./controllers/pirate/searchTheBay.js'));
router.post('/v1/pirate/add', mustBeAuthenticated, require('./controllers/pirate/addMagnet.js'));
/**
* TMDB
*/
router.get('/v1/tmdb/search', require('./controllers/tmdb/searchMedia.js'));
router.get('/v1/tmdb/list/:listname', require('./controllers/tmdb/listSearch.js'));
router.get('/v1/tmdb/:mediaId', require('./controllers/tmdb/readMedia.js'));
/**
* git
*/
router.post("/v1/git/dump", require("./controllers/git/dumpHook.js"));
router.post('/v1/git/dump', require('./controllers/git/dumpHook.js'));
/**
* misc
*/
router.get("/v1/emoji", require("./controllers/misc/emoji.js"));
router.get('/v1/emoji', require('./controllers/misc/emoji.js'));
// REGISTER OUR ROUTES -------------------------------
// all of our routes will be prefixed with /api
app.use("/api", router);
app.use('/api', router);
module.exports = app;

30
seasoned_api/src/webserver/controllers/info/movieInfo.js Normal file
View File

@@ -0,0 +1,30 @@
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const Plex = require('src/plex/plex');
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
const plex = new Plex(configuration.get('plex', 'ip'));
/**
* Controller: Retrieve information for a movie
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
async function movieInfoController(req, res) {
const movieId = req.params.id;
const { credits } = req.query;
const movie = await tmdb.movieInfo(movieId, credits);
plex.existsInPlex(movie)
.catch((error) => { console.log('Error when searching plex'); })
.then(() => {
console.log('movie', movie)
res.send(movie);
}).catch((error) => {
res.status(404).send({ success: false, error: error.message });
});
}
module.exports = movieInfoController;

24
seasoned_api/src/webserver/controllers/info/personInfo.js Normal file
View File

@@ -0,0 +1,24 @@
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
/**
* Controller: Retrieve information for a person
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
function personInfoController(req, res) {
const personId = req.params.id;
tmdb.personInfo(personId)
.then((person) => {
res.send(person);
}).catch((error) => {
res.status(404).send({ success: false, error: error.message });
});
}
module.exports = personInfoController;

31
seasoned_api/src/webserver/controllers/info/showInfo.js Normal file
View File

@@ -0,0 +1,31 @@
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const Plex = require('src/plex/plex');
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
const plex = new Plex(configuration.get('plex', 'ip'));
/**
* Controller: Retrieve information for a show
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
async function showInfoController(req, res) {
const showId = req.params.id;
const { credits } = req.query;
const show = await tmdb.showInfo(showId, credits);
plex.existsInPlex(show)
.catch((error) => { console.log('Error when searching plex'); })
.then(() => {
console.log('show', show)
res.send(show);
}).catch((error) => {
res.status(404).send({ success: false, error: error.message });
});
}
module.exports = showInfoController;

101
seasoned_api/src/webserver/controllers/list/listController.js
View File

@@ -1,6 +1,8 @@
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const tmdb = new TMDB(configuration.get('tmdb', 'apiKey'));
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
// there should be a translate function from query params to
// tmdb list that is valid. Should it be a helper function or does it
@@ -14,55 +16,70 @@ const tmdb = new TMDB(configuration.get('tmdb', 'apiKey'));
// + newly created (tv/latest).
// + movie/latest
//
function handleError(error, res) {
const { status, message } = error;
if (status && message) {
res.status(status).send({ success: false, message })
} else {
console.log('caught list controller error', error)
res.status(500).send({ message: 'An unexpected error occured while requesting list'})
}
function getTmdbMovieList(res, listname, page) {
Promise.resolve()
.then(() => tmdb.movieList(listname, page))
.then((response) => res.send(response))
.catch((error) => {
res.status(500).send({ success: false, error: error.message });
})
}
function handleListResponse(response, res) {
return res.send(response)
.catch(error => handleError(error, res))
function getTmdbShowList(res, listname, page) {
Promise.resolve()
.then(() => tmdb.showList(listname, page))
.then((response) => res.send(response))
.catch((error) => {
res.status(500).send({ success: false, error: error.message });
})
}
function fetchTmdbList(req, res, listname, type) {
exports.nowPlayingMovies = (req, res) => {
const { page } = req.query;
const listname = 'miscNowPlayingMovies'
if (type === 'movie') {
return tmdb.movieList(listname, page)
.then(listResponse => res.send(listResponse))
.catch(error => handleError(error, res))
} else if (type === 'show') {
return tmdb.showList(listname, page)
.then(listResponse => res.send(listResponse))
.catch(error => handleError(error, res))
}
handleError({
status: 400,
message: `'${type}' is not a valid list type.`
}, res)
getTmdbMovieList(res, listname, page);
}
const nowPlayingMovies = (req, res) => fetchTmdbList(req, res, 'miscNowPlayingMovies', 'movie')
const popularMovies = (req, res) => fetchTmdbList(req, res, 'miscPopularMovies', 'movie')
const topRatedMovies = (req, res) => fetchTmdbList(req, res, 'miscTopRatedMovies', 'movie')
const upcomingMovies = (req, res) => fetchTmdbList(req, res, 'miscUpcomingMovies', 'movie')
const nowPlayingShows = (req, res) => fetchTmdbList(req, res, 'tvOnTheAir', 'show')
const popularShows = (req, res) => fetchTmdbList(req, res, 'miscPopularTvs', 'show')
const topRatedShows = (req, res) => fetchTmdbList(req, res, 'miscTopRatedTvs', 'show')
exports.popularMovies = (req, res) => {
const { page } = req.query;
const listname = 'miscPopularMovies'
module.exports = {
nowPlayingMovies,
popularMovies,
topRatedMovies,
upcomingMovies,
nowPlayingShows,
popularShows,
topRatedShows
getTmdbMovieList(res, listname, page);
}
exports.topRatedMovies = (req, res) => {
const { page } = req.query;
const listname = 'miscTopRatedMovies'
getTmdbMovieList(res, listname, page);
}
exports.upcomingMovies = (req, res) => {
const { page } = req.query;
const listname = 'miscUpcomingMovies'
getTmdbMovieList(res, listname, page);
}
exports.nowPlayingShows = (req, res) => {
const { page } = req.query;
const listname = 'tvOnTheAir'
getTmdbShowList(res, listname, page);
}
exports.popularShows = (req, res) => {
const { page } = req.query;
const listname = 'miscPopularTvs'
getTmdbShowList(res, listname, page);
}
exports.topRatedShows = (req, res) => {
const { page } = req.query;
const listname = 'miscTopRatedTvs'
getTmdbShowList(res, listname, page);
}

24
seasoned_api/src/webserver/controllers/movie/credits.js
View File

@@ -1,24 +0,0 @@
const configuration = require('src/config/configuration').getInstance();
const TMDB = require('src/tmdb/tmdb');
const tmdb = new TMDB(configuration.get('tmdb', 'apiKey'));
const movieCreditsController = (req, res) => {
const movieId = req.params.id;
tmdb.movieCredits(movieId)
.then(credits => res.send(credits.createJsonResponse()))
.catch(error => {
const { status, message } = error;
if (status && message) {
res.status(status).send({ success: false, message })
} else {
// TODO log unhandled errors
console.log('caugth movie credits controller error', error)
res.status(500).send({ message: 'An unexpected error occured while requesting movie credits' })
}
})
}
module.exports = movieCreditsController;

71
seasoned_api/src/webserver/controllers/movie/info.js
View File

@@ -1,71 +0,0 @@
const configuration = require("src/config/configuration").getInstance();
const TMDB = require("src/tmdb/tmdb");
const Plex = require("src/plex/plex");
const tmdb = new TMDB(configuration.get("tmdb", "apiKey"));
const plex = new Plex(configuration.get("plex", "ip"));
function handleError(error, res) {
const { status, message } = error;
if (status && message) {
res.status(status).send({ success: false, message });
} else {
console.log("caught movieinfo controller error", error);
res.status(500).send({
message: "An unexpected error occured while requesting movie info"
});
}
}
/**
* Controller: Retrieve information for a movie
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
async function movieInfoController(req, res) {
const movieId = req.params.id;
let { credits, release_dates, check_existance } = req.query;
credits && credits.toLowerCase() === "true"
? (credits = true)
: (credits = false);
release_dates && release_dates.toLowerCase() === "true"
? (release_dates = true)
: (release_dates = false);
check_existance && check_existance.toLowerCase() === "true"
? (check_existance = true)
: (check_existance = false);
let tmdbQueue = [tmdb.movieInfo(movieId)];
if (credits) tmdbQueue.push(tmdb.movieCredits(movieId));
if (release_dates) tmdbQueue.push(tmdb.movieReleaseDates(movieId));
try {
const [Movie, Credits, ReleaseDates] = await Promise.all(tmdbQueue);
const movie = Movie.createJsonResponse();
if (Credits) movie.credits = Credits.createJsonResponse();
if (ReleaseDates)
movie.release_dates = ReleaseDates.createJsonResponse().results;
if (check_existance) {
try {
movie.exists_in_plex = await plex.existsInPlex(movie);
} catch (error) {
if (error.status === 401) {
console.log("Unathorized request, check plex server LAN settings");
} else {
console.log("Unkown error from plex!");
}
console.log(error);
}
}
res.send(movie);
} catch (error) {
handleError(error, res);
}
}
module.exports = movieInfoController;

24
seasoned_api/src/webserver/controllers/movie/releaseDates.js
View File

@@ -1,24 +0,0 @@
const configuration = require('src/config/configuration').getInstance();
const TMDB = require('src/tmdb/tmdb');
const tmdb = new TMDB(configuration.get('tmdb', 'apiKey'));
const movieReleaseDatesController = (req, res) => {
const movieId = req.params.id;
tmdb.movieReleaseDates(movieId)
.then(releaseDates => res.send(releaseDates.createJsonResponse()))
.catch(error => {
const { status, message } = error;
if (status && message) {
res.status(status).send({ success: false, message })
} else {
// TODO log unhandled errors : here our at tmdbReleaseError ?
console.log('caugth release dates controller error', error)
res.status(500).send({ message: 'An unexpected error occured while requesting movie credits' })
}
})
}
module.exports = movieReleaseDatesController;

26
seasoned_api/src/webserver/controllers/person/credits.js
View File

@@ -1,26 +0,0 @@
const configuration = require("src/config/configuration").getInstance();
const TMDB = require("src/tmdb/tmdb");
const tmdb = new TMDB(configuration.get("tmdb", "apiKey"));
const personCreditsController = (req, res) => {
const personId = req.params.id;
return tmdb
.personCredits(personId)
.then(credits => res.send(credits))
.catch(error => {
const { status, message } = error;
if (status && message) {
res.status(status).send({ success: false, message });
} else {
// TODO log unhandled errors
console.log("caugth show credits controller error", error);
res.status(500).send({
message: "An unexpected error occured while requesting person credits"
});
}
});
};
module.exports = personCreditsController;

49
seasoned_api/src/webserver/controllers/person/info.js
View File

@@ -1,49 +0,0 @@
const configuration = require("src/config/configuration").getInstance();
const TMDB = require("src/tmdb/tmdb");
const tmdb = new TMDB(configuration.get("tmdb", "apiKey"));
function handleError(error, res) {
const { status, message } = error;
if (status && message) {
res.status(status).send({ success: false, message });
} else {
console.log("caught personinfo controller error", error);
res.status(500).send({
message: "An unexpected error occured while requesting person info."
});
}
}
/**
* Controller: Retrieve information for a person
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
async function personInfoController(req, res) {
const personId = req.params.id;
let { credits } = req.query;
arguments;
credits && credits.toLowerCase() === "true"
? (credits = true)
: (credits = false);
let tmdbQueue = [tmdb.personInfo(personId)];
if (credits) tmdbQueue.push(tmdb.personCredits(personId));
try {
const [Person, Credits] = await Promise.all(tmdbQueue);
const person = Person.createJsonResponse();
if (credits) person.credits = Credits.createJsonResponse();
return res.send(person);
} catch (error) {
handleError(error, res);
}
}
module.exports = personInfoController;

4
seasoned_api/src/webserver/controllers/pirate/addMagnet.js
View File

@@ -17,8 +17,8 @@ function addMagnet(req, res) {
.then((result) => {
res.send(result);
})
.catch(error => {
res.status(500).send({ success: false, message: error.message });
.catch((error) => {
res.status(500).send({ success: false, error: error.message });
});
}

28
seasoned_api/src/webserver/controllers/pirate/searchTheBay.js
View File

@@ -1,11 +1,11 @@
/*
* @Author: KevinMidboe
* @Date: 2017-10-21 09:54:31
* @Last Modified by: KevinMidboe
* @Last Modified time: 2018-02-26 19:56:32
*/
* @Author: KevinMidboe
* @Date: 2017-10-21 09:54:31
* @Last Modified by: KevinMidboe
* @Last Modified time: 2018-02-26 19:56:32
*/
const PirateRepository = require("src/pirate/pirateRepository");
const PirateRepository = require('src/pirate/pirateRepository');
// const pirateRepository = new PirateRepository();
/**
@@ -15,15 +15,15 @@ const PirateRepository = require("src/pirate/pirateRepository");
* @returns {Callback}
*/
function updateRequested(req, res) {
const { query, page, type } = req.query;
const { query, page, type } = req.query;
PirateRepository.SearchPiratebay(query, page, type)
.then(result => {
res.send({ success: true, results: result });
})
.catch(error => {
res.status(401).send({ success: false, message: error.message });
});
PirateRepository.SearchPiratebay(query, page, type)
.then((result) => {
res.send({ success: true, results: result });
})
.catch((error) => {
res.status(401).send({ success: false, error: error.message });
});
}
module.exports = updateRequested;

2
seasoned_api/src/webserver/controllers/plex/fetchRequested.js
View File

@@ -17,7 +17,7 @@ function fetchRequestedController(req, res) {
res.send({ success: true, results: requestedItems, total_results: requestedItems.length });
})
.catch((error) => {
res.status(401).send({ success: false, message: error.message });
res.status(401).send({ success: false, error: error.message });
});
}

6
seasoned_api/src/webserver/controllers/plex/plexPlaying.js
View File

@@ -5,11 +5,11 @@ const plexRepository = new PlexRepository(configuration.get('plex', 'ip'));
function playingController(req, res) {
plexRepository.nowPlaying()
.then(movies => {
.then((movies) => {
res.send(movies);
})
.catch(error => {
res.status(500).send({ success: false, message: error.message });
.catch((error) => {
res.status(500).send({ success: false, error: error.message });
});
}

6
seasoned_api/src/webserver/controllers/plex/readRequest.js
View File

@@ -12,10 +12,10 @@ function readRequestController(req, res) {
const mediaId = req.params.mediaId;
const { type } = req.query;
requestRepository.lookup(mediaId, type)
.then(movies => {
.then((movies) => {
res.send(movies);
}).catch(error => {
res.status(404).send({ success: false, message: error.message });
}).catch((error) => {
res.status(404).send({ success: false, error: error.message });
});
}

8
seasoned_api/src/webserver/controllers/plex/search.js
View File

@@ -11,14 +11,14 @@ const plex = new Plex(configuration.get('plex', 'ip'));
function searchPlexController(req, res) {
const { query, type } = req.query;
plex.search(query, type)
.then(movies => {
.then((movies) => {
if (movies.length > 0) {
res.send(movies);
} else {
res.status(404).send({ success: false, message: 'Search query did not give any results from plex.'})
res.status(404).send({ success: false, error: 'Search query did not give any results from plex.'})
}
}).catch(error => {
res.status(500).send({ success: false, message: error.message });
}).catch((error) => {
res.status(500).send({ success: false, error: error.message });
});
}

8
seasoned_api/src/webserver/controllers/plex/searchMedia.js
View File

@@ -14,15 +14,15 @@ function searchMediaController(req, res) {
const { query } = req.query;
plexRepository.search(query)
.then(media => {
.then((media) => {
if (media !== undefined || media.length > 0) {
res.send(media);
} else {
res.status(404).send({ success: false, message: 'Search query did not return any results.' });
res.status(404).send({ success: false, error: 'Search query did not return any results.' });
}
})
.catch(error => {
res.status(500).send({ success: false, message: error.message });
.catch((error) => {
res.status(500).send({ success: false, error: error.message });
});
}

32
seasoned_api/src/webserver/controllers/plex/searchRequest.js
View File

@@ -1,24 +1,26 @@
const SearchHistory = require("src/searchHistory/searchHistory");
const Cache = require("src/tmdb/cache");
const RequestRepository = require("src/plex/requestRepository.js");
const SearchHistory = require('src/searchHistory/searchHistory');
const Cache = require('src/tmdb/cache');
const RequestRepository = require('src/plex/requestRepository.js');
const cache = new Cache();
const requestRepository = new RequestRepository(cache);
const searchHistory = new SearchHistory();
function searchRequestController(req, res) {
const { query, page, type } = req.query;
const username = req.loggedInUser ? req.loggedInUser.username : null;
Promise.resolve()
.then(() => searchHistory.create(username, query))
.then(() => requestRepository.search(query, page, type))
.then(searchResult => {
res.send(searchResult);
})
.catch(error => {
res.status(500).send({ success: false, message: error.message });
});
function searchRequestController(req, res) {
const user = req.loggedInUser;
const { query, page, type } = req.query;
const username = user === undefined ? undefined : user.username;
Promise.resolve()
.then(() => searchHistory.create(username, query))
.then(() => requestRepository.search(query, page, type))
.then((searchResult) => {
res.send(searchResult);
})
.catch((error) => {
res.status(500).send({ success: false, error: error });
});
}
module.exports = searchRequestController;

72
seasoned_api/src/webserver/controllers/plex/submitRequest.js
View File

@@ -1,16 +1,19 @@
const configuration = require("src/config/configuration").getInstance();
const RequestRepository = require("src/request/request");
const TMDB = require("src/tmdb/tmdb");
const tmdb = new TMDB(configuration.get("tmdb", "apiKey"));
const request = new RequestRepository();
const configuration = require('src/config/configuration').getInstance()
const RequestRepository = require('src/request/request');
const Cache = require('src/tmdb/cache')
const TMDB = require('src/tmdb/tmdb')
const tmdbMovieInfo = id => {
return tmdb.movieInfo(id);
};
const cache = new Cache()
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'))
const request = new RequestRepository()
const tmdbShowInfo = id => {
return tmdb.showInfo(id);
};
const tmdbMovieInfo = (id) => {
return tmdb.movieInfo(id)
}
const tmdbShowInfo = (id) => {
return tmdb.showInfo(id)
}
/**
* Controller: POST a media id to be donwloaded
@@ -21,43 +24,28 @@ const tmdbShowInfo = id => {
function submitRequestController(req, res) {
// This is the id that is the param of the url
const id = req.params.mediaId;
const type = req.query.type ? req.query.type.toLowerCase() : undefined;
const ip = req.headers["x-forwarded-for"] || req.connection.remoteAddress;
const user_agent = req.headers["user-agent"];
const username = req.loggedInUser ? req.loggedInUser.username : null;
const type = req.query.type ? req.query.type.toLowerCase() : undefined
const ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;
const user_agent = req.headers['user-agent'];
const user = req.loggedInUser;
let mediaFunction = undefined
let mediaFunction = undefined;
if (type === "movie") {
console.log("movie");
mediaFunction = tmdbMovieInfo;
} else if (type === "show") {
console.log("show");
mediaFunction = tmdbShowInfo;
if (type === 'movie') {
console.log('movie')
mediaFunction = tmdbMovieInfo
} else if (type === 'show') {
console.log('show')
mediaFunction = tmdbShowInfo
} else {
res
.status(422)
.send({
success: false,
message: 'Incorrect type. Allowed types: "movie" or "show"'
});
res.status(422).send({ success: false, error: 'Incorrect type. Allowed types: "movie" or "show"'})
}
if (mediaFunction === undefined) {
res.status(200);
return;
}
if (mediaFunction === undefined) { res.status(200); return }
mediaFunction(id)
.then(tmdbMedia =>
request.requestFromTmdb(tmdbMedia, ip, user_agent, username)
)
.then(() =>
res.send({ success: true, message: "Media item successfully requested" })
)
.catch(err =>
res.status(500).send({ success: false, message: err.message })
);
.then(tmdbMedia => request.requestFromTmdb(tmdbMedia, ip, user_agent, user))
.then(() => res.send({ success: true, message: 'Media item successfully requested' }))
.catch(err => res.status(500).send({ success: false, error: err.message }))
}
module.exports = submitRequestController;

2
seasoned_api/src/webserver/controllers/plex/updateRequested.js
View File

@@ -18,7 +18,7 @@ function updateRequested(req, res) {
res.send({ success: true });
})
.catch((error) => {
res.status(401).send({ success: false, message: error.message });
res.status(401).send({ success: false, error: error.message });
});
}

27
seasoned_api/src/webserver/controllers/plex/watchDirectLink.js
View File

@@ -1,27 +0,0 @@
const configuration = require('src/config/configuration').getInstance();
const Plex = require('src/plex/plex');
const plex = new Plex(configuration.get('plex', 'ip'));
/**
* Controller: Search plex for movies, shows and episodes by query
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
function watchDirectLink (req, res) {
const { title, year } = req.query;
plex.getDirectLinkByTitleAndYear(title, year)
.then(plexDirectLink => {
if (plexDirectLink == false)
res.status(404).send({ success: true, link: null })
else
res.status(200).send({ success: true, link: plexDirectLink })
})
.catch(error => {
res.status(500).send({ success: false, message: error.message });
});
}
module.exports = watchDirectLink;

6
seasoned_api/src/webserver/controllers/request/fetchAllRequests.js
View File

@@ -18,9 +18,9 @@ function fetchAllRequests(req, res) {
Promise.resolve()
.then(() => request.fetchAll(page, sort_by, sort_direction, filter, query))
.then(result => res.send(result))
.catch(error => {
res.status(404).send({ success: false, message: error.message });
.then((result) => res.send(result))
.catch((error) => {
res.status(404).send({ success: false, error: error.message });
});
}

9
seasoned_api/src/webserver/controllers/request/getRequest.js
View File

@@ -11,10 +11,11 @@ function fetchAllRequests(req, res) {
const id = req.params.id;
const { type } = req.query;
request.getRequestByIdAndType(id, type)
.then(result => res.send(result))
.catch(error => {
res.status(404).send({ success: false, message: error.message });
Promise.resolve()
.then(() => request.getRequestByIdAndType(id, type))
.then((result) => res.send(result))
.catch((error) => {
res.status(404).send({ success: false, error: error.message });
});
}

77
seasoned_api/src/webserver/controllers/request/requestTmdbId.js
View File

@@ -1,17 +1,18 @@
const configuration = require("src/config/configuration").getInstance();
const TMDB = require("src/tmdb/tmdb");
const RequestRepository = require("src/request/request");
const tmdb = new TMDB(configuration.get("tmdb", "apiKey"));
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const RequestRepository = require('src/request/request');
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
const request = new RequestRepository();
// const { sendSMS } = require("src/notifications/sms");
const tmdbMovieInfo = id => {
return tmdb.movieInfo(id);
};
const tmdbMovieInfo = (id) => {
return tmdb.movieInfo(id)
}
const tmdbShowInfo = id => {
return tmdb.showInfo(id);
};
const tmdbShowInfo = (id) => {
return tmdb.showInfo(id)
}
/**
* Controller: Request by id with type param
@@ -20,48 +21,32 @@ const tmdbShowInfo = id => {
* @returns {Callback}
*/
function requestTmdbIdController(req, res) {
const { id, type } = req.body;
const { id, type } = req.body
console.log('body', req.body)
console.log('id & type', id, type)
const ip = req.headers["x-forwarded-for"] || req.connection.remoteAddress;
const user_agent = req.headers["user-agent"];
const username = req.loggedInUser ? req.loggedInUser.username : null;
const ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;
const user_agent = req.headers['user-agent'];
const user = req.loggedInUser;
let mediaFunction = undefined
let mediaFunction = undefined;
if (id === undefined || type === undefined) {
res.status(422).send({
success: false,
message: "'Missing parameteres: 'id' and/or 'type'"
});
}
if (type === "movie") {
mediaFunction = tmdbMovieInfo;
} else if (type === "show") {
mediaFunction = tmdbShowInfo;
if (type === 'movie') {
console.log('movie')
mediaFunction = tmdbMovieInfo
} else if (type === 'show') {
console.log('show')
mediaFunction = tmdbShowInfo
} else {
res.status(422).send({
success: false,
message: 'Incorrect type. Allowed types: "movie" or "show"'
});
res.status(422).send({ success: false, error: 'Incorrect type. Allowed types: "movie" or "show"'})
}
mediaFunction(id)
// .catch((error) => { console.error(error); res.status(404).send({ success: false, error: 'Id not found' }) })
.then(tmdbMedia => {
request.requestFromTmdb(tmdbMedia, ip, user_agent, username);
// TODO enable SMS
// const url = `https://request.movie?${tmdbMedia.type}=${tmdbMedia.id}`;
// const message = `${tmdbMedia.title} (${tmdbMedia.year}) requested!\n${url}`;
// sendSMS(message);
.catch((error) => { console.error(error); res.status(404).send({ success: false, error: 'Id not found' }) })
.then((tmdbMedia) => request.requestFromTmdb(tmdbMedia, ip, user_agent, user))
.then(() => res.send({success: true, message: 'Request has been submitted.'}))
.catch((error) => {
res.status(501).send({ success: false, error: error.message });
})
.then(() =>
res.send({ success: true, message: "Request has been submitted." })
)
.catch(error => {
res.send({ success: false, message: error.message });
});
}
module.exports = requestTmdbIdController;

49
seasoned_api/src/webserver/controllers/search/movieSearch.js
View File

@@ -1,7 +1,9 @@
const configuration = require("src/config/configuration").getInstance();
const TMDB = require("src/tmdb/tmdb");
const SearchHistory = require("src/searchHistory/searchHistory");
const tmdb = new TMDB(configuration.get("tmdb", "apiKey"));
const SearchHistory = require('src/searchHistory/searchHistory');
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
const searchHistory = new SearchHistory();
/**
@@ -11,30 +13,23 @@ const searchHistory = new SearchHistory();
* @returns {Callback}
*/
function movieSearchController(req, res) {
const { query, page, adult } = req.query;
const username = req.loggedInUser ? req.loggedInUser.username : null;
const includeAdult = adult == "true" ? true : false;
const user = req.loggedInUser;
const { query, page } = req.query;
if (username) {
searchHistory.create(username, query);
}
return tmdb
.movieSearch(query, page, includeAdult)
.then(movieSearchResults => res.send(movieSearchResults))
.catch(error => {
const { status, message } = error;
if (status && message) {
res.status(status).send({ success: false, message });
} else {
// TODO log unhandled errors
console.log("caugth movie search controller error", error);
res.status(500).send({
message: `An unexpected error occured while searching movies with query: ${query}`
});
}
});
Promise.resolve()
.then(() => {
if (user) {
return searchHistory.create(user, query);
}
return null
})
.then(() => tmdb.movieSearch(query, page))
.then((movies) => {
res.send(movies);
})
.catch((error) => {
res.status(500).send({ success: false, error: error.message });
});
}
module.exports = movieSearchController;

57
seasoned_api/src/webserver/controllers/search/multiSearch.js
View File

@@ -1,16 +1,11 @@
const configuration = require("src/config/configuration").getInstance();
const TMDB = require("src/tmdb/tmdb");
const SearchHistory = require("src/searchHistory/searchHistory");
const tmdb = new TMDB(configuration.get("tmdb", "apiKey"));
const SearchHistory = require('src/searchHistory/searchHistory');
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
const searchHistory = new SearchHistory();
function checkAndCreateJsonResponse(result) {
if (typeof result["createJsonResponse"] === "function") {
return result.createJsonResponse();
}
return result;
}
/**
* Controller: Search for multi (movies, shows and people by query and pagey
* @param {Request} req http request variable
@@ -18,31 +13,23 @@ function checkAndCreateJsonResponse(result) {
* @returns {Callback}
*/
function multiSearchController(req, res) {
const { query, page, adult } = req.query;
const username = req.loggedInUser ? req.loggedInUser.username : null;
const user = req.loggedInUser;
const { query, page } = req.query;
if (username) {
searchHistory.create(username, query);
}
return tmdb
.multiSearch(query, page, adult)
.then(multiSearchResults => res.send(multiSearchResults))
.catch(error => {
const { status, message } = error;
if (status && message) {
res.status(status).send({ success: false, message });
} else {
// TODO log unhandled errors
console.log("caugth multi search controller error", error);
res
.status(500)
.send({
message: `An unexpected error occured while searching with query: ${query}`
});
}
});
Promise.resolve()
.then(() => {
if (user) {
return searchHistory.create(user, query);
}
return null
})
.then(() => tmdb.multiSearch(query, page))
.then((result) => {
res.send(result);
})
.catch((error) => {
res.status(500).send({ success: false, error: error.message });
});
}
module.exports = multiSearchController;

49
seasoned_api/src/webserver/controllers/search/personSearch.js
View File

@@ -1,7 +1,9 @@
const configuration = require("src/config/configuration").getInstance();
const TMDB = require("src/tmdb/tmdb");
const SearchHistory = require("src/searchHistory/searchHistory");
const tmdb = new TMDB(configuration.get("tmdb", "apiKey"));
const SearchHistory = require('src/searchHistory/searchHistory');
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
const searchHistory = new SearchHistory();
/**
@@ -11,30 +13,23 @@ const searchHistory = new SearchHistory();
* @returns {Callback}
*/
function personSearchController(req, res) {
const { query, page, adult } = req.query;
const username = req.loggedInUser ? req.loggedInUser.username : null;
const includeAdult = adult == "true" ? true : false;
const user = req.loggedInUser;
const { query, page } = req.query;
if (username) {
searchHistory.create(username, query);
}
return tmdb
.personSearch(query, page, includeAdult)
.then(persons => res.send(persons))
.catch(error => {
const { status, message } = error;
if (status && message) {
res.status(status).send({ success: false, message });
} else {
// TODO log unhandled errors
console.log("caugth person search controller error", error);
res.status(500).send({
message: `An unexpected error occured while searching people with query: ${query}`
});
}
});
Promise.resolve()
.then(() => {
if (user) {
return searchHistory.create(user, query);
}
return null
})
.then(() => tmdb.personSearch(query, page))
.then((person) => {
res.send(person);
})
.catch((error) => {
res.status(500).send({ success: false, error: error.message });
});
}
module.exports = personSearchController;

41
seasoned_api/src/webserver/controllers/search/showSearch.js
View File

@@ -1,7 +1,9 @@
const SearchHistory = require("src/searchHistory/searchHistory");
const configuration = require("src/config/configuration").getInstance();
const TMDB = require("src/tmdb/tmdb");
const tmdb = new TMDB(configuration.get("tmdb", "apiKey"));
const SearchHistory = require('src/searchHistory/searchHistory');
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
const searchHistory = new SearchHistory();
/**
@@ -11,22 +13,23 @@ const searchHistory = new SearchHistory();
* @returns {Callback}
*/
function showSearchController(req, res) {
const { query, page, adult } = req.query;
const username = req.loggedInUser ? req.loggedInUser.username : null;
const includeAdult = adult == "true" ? true : false;
const user = req.loggedInUser;
const { query, page } = req.query;
if (username) {
searchHistory.create(username, query);
}
return tmdb
.showSearch(query, page, includeAdult)
.then(shows => {
res.send(shows);
})
.catch(error => {
res.status(500).send({ success: false, message: error.message });
});
Promise.resolve()
.then(() => {
if (user) {
return searchHistory.create(user, query);
}
return null
})
.then(() => tmdb.showSearch(query, page))
.then((shows) => {
res.send(shows);
})
.catch((error) => {
res.status(500).send({ success: false, error: error.message });
});
}
module.exports = showSearchController;

2
seasoned_api/src/webserver/controllers/seasoned/readStrays.js
View File

@@ -10,7 +10,7 @@ function readStraysController(req, res) {
res.send(strays);
})
.catch((error) => {
res.status(500).send({ success: false, message: error.message });
res.status(500).send({ success: false, error: error.message });
});
}

2
seasoned_api/src/webserver/controllers/seasoned/strayById.js
View File

@@ -10,7 +10,7 @@ function strayByIdController(req, res) {
res.send(stray);
})
.catch((error) => {
res.status(500).send({ success: false, message: error.message });
res.status(500).send({ success: false, error: error.message });
});
}

2
seasoned_api/src/webserver/controllers/seasoned/verifyStray.js
View File

@@ -10,7 +10,7 @@ function verifyStrayController(req, res) {
res.send({ success: true, message: 'Episode verified' });
})
.catch((error) => {
res.status(500).send({ success: false, message: error.message });
res.status(500).send({ success: false, error: error.message });
});
}

23
seasoned_api/src/webserver/controllers/show/credits.js
View File

@@ -1,23 +0,0 @@
const configuration = require('src/config/configuration').getInstance();
const TMDB = require('src/tmdb/tmdb');
const tmdb = new TMDB(configuration.get('tmdb', 'apiKey'));
const showCreditsController = (req, res) => {
const showId = req.params.id;
tmdb.showCredits(showId)
.then(credits => res.send(credits.createJsonResponse()))
.catch(error => {
const { status, message } = error;
if (status && message) {
res.status(status).send({ success: false, message })
} else {
// TODO log unhandled errors
console.log('caugth show credits controller error', error)
res.status(500).send({ message: 'An unexpected error occured while requesting show credits' })
}
})
}
module.exports = showCreditsController;

54
seasoned_api/src/webserver/controllers/show/info.js
View File

@@ -1,54 +0,0 @@
const configuration = require('src/config/configuration').getInstance();
const TMDB = require('src/tmdb/tmdb');
const Plex = require('src/plex/plex');
const tmdb = new TMDB(configuration.get('tmdb', 'apiKey'));
const plex = new Plex(configuration.get('plex', 'ip'));
function handleError(error, res) {
const { status, message } = error;
if (status && message) {
res.status(status).send({ success: false, message })
} else {
console.log('caught showinfo controller error', error)
res.status(500).send({
message: 'An unexpected error occured while requesting show info.'
})
}
}
/**
* Controller: Retrieve information for a show
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
async function showInfoController(req, res) {
const showId = req.params.id;
let { credits, check_existance } = req.query;
credits && credits.toLowerCase() === 'true' ? credits = true : credits = false
check_existance && check_existance.toLowerCase() === 'true' ? check_existance = true : check_existance = false
let tmdbQueue = [tmdb.showInfo(showId)]
if (credits)
tmdbQueue.push(tmdb.showCredits(showId))
try {
const [Show, Credits] = await Promise.all(tmdbQueue)
const show = Show.createJsonResponse()
if (credits)
show.credits = Credits.createJsonResponse()
if (check_existance)
show.exists_in_plex = await plex.existsInPlex(show)
res.send(show)
} catch(error) {
handleError(error, res)
}
}
module.exports = showInfoController;

25
seasoned_api/src/webserver/controllers/tmdb/listSearch.js Normal file
View File

@@ -0,0 +1,25 @@
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
/**
* Controller: Retrieve nowplaying movies / now airing shows
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
function listSearchController(req, res) {
const listname = req.params.listname;
const { type, page } = req.query;
tmdb.listSearch(listname, type, page)
.then((results) => {
res.send(results);
}).catch((error) => {
res.status(404).send({ success: false, error: error.message });
});
}
module.exports = listSearchController;

25
seasoned_api/src/webserver/controllers/tmdb/readMedia.js Normal file
View File

@@ -0,0 +1,25 @@
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
/**
* Controller: Retrieve information for a movie
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
function readMediaController(req, res) {
const mediaId = req.params.mediaId;
const { type } = req.query;
tmdb.lookup(mediaId, type)
.then((movies) => {
res.send(movies);
}).catch((error) => {
res.status(404).send({ success: false, error: error.message });
});
}
module.exports = readMediaController;

31
seasoned_api/src/webserver/controllers/tmdb/searchMedia.js Normal file
View File

@@ -0,0 +1,31 @@
const configuration = require('src/config/configuration').getInstance();
const Cache = require('src/tmdb/cache');
const TMDB = require('src/tmdb/tmdb');
const cache = new Cache();
const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
/**
* Controller: Search for movies by query, page and optional type
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
function searchMediaController(req, res) {
const { query, page, type } = req.query;
Promise.resolve()
.then(() => tmdb.search(query, page, type))
.then((movies) => {
if (movies !== undefined || movies.length > 0) {
res.send(movies);
} else {
res.status(404).send({ success: false, error: 'Search query did not return any results.' });
}
})
.catch((error) => {
res.status(500).send({ success: false, error: error.message });
});
}
module.exports = searchMediaController;

93
seasoned_api/src/webserver/controllers/user/authenticatePlexAccount.js
View File

@@ -1,93 +0,0 @@
const UserRepository = require("src/user/userRepository");
const userRepository = new UserRepository();
const fetch = require("node-fetch");
const FormData = require("form-data");
function handleError(error, res) {
let { status, message, source } = error;
if (status && message) {
if (status === 401) {
(message = "Unauthorized. Please check plex credentials."),
(source = "plex");
}
res.status(status).send({ success: false, message, source });
} else {
console.log("caught authenticate plex account controller error", error);
res.status(500).send({
message:
"An unexpected error occured while authenticating your account with plex",
source
});
}
}
function handleResponse(response) {
if (!response.ok) {
throw {
success: false,
status: response.status,
message: response.statusText
};
}
return response.json();
}
function plexAuthenticate(username, password) {
const url = "https://plex.tv/api/v2/users/signin";
const form = new FormData();
form.append("login", username);
form.append("password", password);
form.append("rememberMe", "false");
const headers = {
Accept: "application/json, text/plain, */*",
"Content-Type": form.getHeaders()["content-type"],
"X-Plex-Client-Identifier": "seasonedRequest"
};
const options = {
method: "POST",
headers,
body: form
};
return fetch(url, options).then(resp => handleResponse(resp));
}
function link(req, res) {
const user = req.loggedInUser;
const { username, password } = req.body;
return plexAuthenticate(username, password)
.then(plexUser => userRepository.linkPlexUserId(user.username, plexUser.id))
.then(response =>
res.send({
success: true,
message:
"Successfully authenticated and linked plex account with seasoned request."
})
)
.catch(error => handleError(error, res));
}
function unlink(req, res) {
const username = req.loggedInUser ? req.loggedInUser.username : null;
return userRepository
.unlinkPlexUserId(username)
.then(response =>
res.send({
success: true,
message: "Successfully unlinked plex account from seasoned request."
})
)
.catch(error => handleError(error, res));
}
module.exports = {
link,
unlink
};

24
seasoned_api/src/webserver/controllers/user/history.js Normal file
View File

@@ -0,0 +1,24 @@
const SearchHistory = require('src/searchHistory/searchHistory');
const searchHistory = new SearchHistory();
/**
* Controller: Retrieves search history of a logged in user
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
function historyController(req, res) {
const user = req.loggedInUser;
const username = user === undefined ? undefined : user.username;
searchHistory.read(username)
.then((searchQueries) => {
res.send({ success: true, searchQueries });
})
.catch((error) => {
res.status(404).send({ success: false, error: error });
});
}
module.exports = historyController;

64
seasoned_api/src/webserver/controllers/user/login.js
View File

@@ -1,61 +1,33 @@
const User = require("src/user/user");
const Token = require("src/user/token");
const UserSecurity = require("src/user/userSecurity");
const UserRepository = require("src/user/userRepository");
const configuration = require("src/config/configuration").getInstance();
const User = require('src/user/user');
const Token = require('src/user/token');
const UserSecurity = require('src/user/userSecurity');
const UserRepository = require('src/user/userRepository');
const configuration = require('src/config/configuration').getInstance();
const secret = configuration.get("authentication", "secret");
const secret = configuration.get('authentication', 'secret');
const userSecurity = new UserSecurity();
const userRepository = new UserRepository();
// TODO look to move some of the token generation out of the reach of the final "catch-all"
// catch including the, maybe sensitive, error message.
const isProduction = process.env.NODE_ENV === "production";
const cookieOptions = {
httpOnly: false,
secure: isProduction,
maxAge: 90 * 24 * 3600000, // 90 days
sameSite: isProduction ? "Strict" : "Lax"
};
/**
* Controller: Log in a user provided correct credentials.
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
async function loginController(req, res) {
const user = new User(req.body.username);
const password = req.body.password;
function loginController(req, res) {
const user = new User(req.body.username);
const password = req.body.password;
try {
const [loggedIn, isAdmin, settings] = await Promise.all([
userSecurity.login(user, password),
userRepository.checkAdmin(user),
userRepository.getSettings(user.username)
]);
if (!loggedIn) {
return res.status(503).send({
success: false,
message: "Unexpected error! Unable to create user."
userSecurity.login(user, password)
.then(() => userRepository.checkAdmin(user))
.then((checkAdmin) => {
const token = new Token(user).toString(secret);
const admin_state = checkAdmin === 1 ? true : false;
res.send({ success: true, token, admin: admin_state });
})
.catch((error) => {
res.status(401).send({ success: false, error: error.message });
});
}
const token = new Token(
user,
isAdmin === 1 ? true : false,
settings
).toString(secret);
return res.cookie("authorization", token, cookieOptions).status(200).send({
success: true,
message: "Welcome to request.movie!"
});
} catch (error) {
return res.status(401).send({ success: false, message: error.message });
}
}
module.exports = loginController;

16
seasoned_api/src/webserver/controllers/user/logout.js
View File

@@ -1,16 +0,0 @@
/**
* Controller: Log out a user (destroy authorization token)
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
async function logoutController(req, res) {
res.clearCookie("authorization");
return res.status(200).send({
success: true,
message: "Logged out, see you later!"
});
}
module.exports = logoutController;

52
seasoned_api/src/webserver/controllers/user/register.js
View File

@@ -1,21 +1,13 @@
const User = require("src/user/user");
const Token = require("src/user/token");
const UserSecurity = require("src/user/userSecurity");
const UserRepository = require("src/user/userRepository");
const configuration = require("src/config/configuration").getInstance();
const User = require('src/user/user');
const Token = require('src/user/token');
const UserSecurity = require('src/user/userSecurity');
const UserRepository = require('src/user/userRepository');
const configuration = require('src/config/configuration').getInstance();
const secret = configuration.get("authentication", "secret");
const secret = configuration.get('authentication', 'secret');
const userSecurity = new UserSecurity();
const userRepository = new UserRepository();
const isProduction = process.env.NODE_ENV === "production";
const cookieOptions = {
httpOnly: false,
secure: isProduction,
maxAge: 90 * 24 * 3600000, // 90 days
sameSite: isProduction ? "Strict" : "Lax"
};
/**
* Controller: Register a new user
* @param {Request} req http request variable
@@ -23,25 +15,21 @@ const cookieOptions = {
* @returns {Callback}
*/
function registerController(req, res) {
const user = new User(req.body.username, req.body.email);
const password = req.body.password;
const user = new User(req.body.username, req.body.email);
const password = req.body.password;
userSecurity
.createNewUser(user, password)
.then(() => {
const token = new Token(user, false).toString(secret);
return res
.cookie("authorization", token, cookieOptions)
.status(200)
.send({
success: true,
message: "Welcome to Seasoned!"
});
})
.catch(error => {
res.status(401).send({ success: false, message: error.message });
});
userSecurity.createNewUser(user, password)
.then(() => userRepository.checkAdmin(user))
.then((checkAdmin) => {
const token = new Token(user).toString(secret);
const admin_state = checkAdmin === 1 ? true : false;
res.send({
success: true, message: 'Welcome to Seasoned!', token, admin: admin_state,
});
})
.catch((error) => {
res.status(401).send({ success: false, error: error.message });
});
}
module.exports = registerController;

22
seasoned_api/src/webserver/controllers/user/requests.js
View File

@@ -1,4 +1,4 @@
const RequestRepository = require("src/plex/requestRepository.js");
const RequestRepository = require('src/plex/requestRepository.js');
const requestRepository = new RequestRepository();
@@ -9,20 +9,16 @@ const requestRepository = new RequestRepository();
* @returns {Callback}
*/
function requestsController(req, res) {
const username = req.loggedInUser ? req.loggedInUser.username : null;
const user = req.loggedInUser;
requestRepository
.userRequests(username)
.then(requests => {
res.send({
success: true,
results: requests,
total_results: requests.length
requestRepository.userRequests(user)
.then((requests) => {
res.send({ success: true, results: requests, total_results: requests.length });
})
.catch((error) => {
console.log(error)
res.status(500).send({ success: false, error: error });
});
})
.catch(error => {
res.status(500).send({ success: false, message: error.message });
});
}
module.exports = requestsController;

24
seasoned_api/src/webserver/controllers/user/searchHistory.js
View File

@@ -1,24 +0,0 @@
const SearchHistory = require("src/searchHistory/searchHistory");
const searchHistory = new SearchHistory();
/**
* Controller: Retrieves search history of a logged in user
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
function historyController(req, res) {
const username = req.loggedInUser ? req.loggedInUser.username : null;
searchHistory
.read(username)
.then(searchQueries => {
res.send({ success: true, searchQueries });
})
.catch(error => {
res.status(404).send({ success: false, message: error.message });
});
}
module.exports = historyController;

41
seasoned_api/src/webserver/controllers/user/settings.js
View File

@@ -1,41 +0,0 @@
const UserRepository = require("src/user/userRepository");
const userRepository = new UserRepository();
/**
* Controller: Retrieves settings of a logged in user
* @param {Request} req http request variable
* @param {Response} res
* @returns {Callback}
*/
const getSettingsController = (req, res) => {
const username = req.loggedInUser ? req.loggedInUser.username : null;
userRepository
.getSettings(username)
.then(settings => {
res.send({ success: true, settings });
})
.catch(error => {
res.status(404).send({ success: false, message: error.message });
});
};
const updateSettingsController = (req, res) => {
const username = req.loggedInUser ? req.loggedInUser.username : null;
const idempotencyKey = req.headers("Idempotency-Key"); // TODO implement better transactions
const { dark_mode, emoji } = req.body;
userRepository
.updateSettings(username, dark_mode, emoji)
.then(settings => {
res.send({ success: true, settings });
})
.catch(error => {
res.status(404).send({ success: false, message: error.message });
});
};
module.exports = {
getSettingsController,
updateSettingsController
};

Some files were not shown because too many files have changed in this diff Show More