mirror of https://github.com/aruppi/aruppi-api.git
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
607 lines
15 KiB
JavaScript
607 lines
15 KiB
JavaScript
const rss = require('rss-to-json');
|
|
|
|
const {
|
|
homgot
|
|
} = require('../api/apiCall');
|
|
|
|
const {
|
|
jkanimeInfo,
|
|
animeflvGenres,
|
|
animeflvInfo,
|
|
imageUrlToBase64,
|
|
getAnimeCharacters,
|
|
getAnimeVideoPromo,
|
|
animeExtraInfo,
|
|
searchAnime,
|
|
transformUrlServer,
|
|
obtainPreviewNews,
|
|
structureThemes,
|
|
getAnimes,
|
|
getDirectory,
|
|
helper,
|
|
videoServersJK,
|
|
getThemes
|
|
} = require('../utils/index');
|
|
|
|
const ThemeParser = require('../utils/animetheme');
|
|
const parserThemes = new ThemeParser()
|
|
|
|
const {
|
|
BASE_ANIMEFLV_JELU, BASE_JIKAN, BASE_IVOOX, BASE_QWANT, BASE_YOUTUBE, GENRES_URL, BASE_THEMEMOE
|
|
} = require('./urls');
|
|
|
|
const schedule = async (day) =>{
|
|
|
|
let options = { parse: true }
|
|
const data = await homgot(`${BASE_JIKAN}schedule/${day.current}`, options);
|
|
const body = data[day.current];
|
|
const promises = []
|
|
|
|
body.map(doc =>{
|
|
|
|
promises.push({
|
|
title: doc.title,
|
|
malid: doc.mal_id,
|
|
image: doc.image_url
|
|
});
|
|
|
|
});
|
|
|
|
return promises;
|
|
|
|
};
|
|
|
|
const top = async (type, subtype, page) =>{
|
|
let options = { parse: true }
|
|
const data = await homgot(`${BASE_JIKAN}top/${type}/${page}/${subtype}`, options);
|
|
return data.top;
|
|
};
|
|
|
|
const getAllAnimes = async () =>{
|
|
|
|
let data = await getAnimes()
|
|
|
|
return data.map(item => ({
|
|
index: item[0],
|
|
animeId: item[3],
|
|
title: item[1],
|
|
id: item[2],
|
|
type: item[4]
|
|
}));
|
|
|
|
};
|
|
|
|
const getAllDirectory = async () =>{ return await getDirectory(); };
|
|
|
|
const getAnitakume = async () =>{
|
|
|
|
const promises = []
|
|
|
|
await rss.load(BASE_IVOOX).then(rss => {
|
|
|
|
const body = JSON.parse(JSON.stringify(rss, null, 3)).items
|
|
body.map(doc =>{
|
|
|
|
let time = new Date(doc.created)
|
|
const monthNames = ["Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre"];
|
|
|
|
let day = time.getDate()
|
|
let month = monthNames[time.getMonth()]
|
|
let year = time.getFullYear()
|
|
let date
|
|
|
|
if(month < 10){
|
|
date = `${day} de 0${month} de ${year}`
|
|
}else{
|
|
date = `${day} de ${month} de ${year}`
|
|
}
|
|
|
|
promises.push({
|
|
title: doc.title,
|
|
duration: doc.itunes_duration,
|
|
created: date,
|
|
mp3: doc.enclosures.map(x => x.url)
|
|
});
|
|
});
|
|
|
|
});
|
|
|
|
return promises;
|
|
|
|
};
|
|
|
|
const getNews = async (pageRss) =>{
|
|
|
|
const promises = []
|
|
|
|
for(let i = 0; i <= pageRss.length -1; i++) {
|
|
|
|
await rss.load(pageRss[i].url).then(rss => {
|
|
|
|
const body = JSON.parse(JSON.stringify(rss, null, 3)).items
|
|
body.map(doc => {
|
|
|
|
promises.push({
|
|
title: doc.title,
|
|
url: doc.link,
|
|
author: pageRss[i].author,
|
|
thumbnail: obtainPreviewNews(doc[pageRss[i].content]),
|
|
content: doc[pageRss[i].content]
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
return promises;
|
|
|
|
};
|
|
|
|
const season = async (year, type) =>{
|
|
|
|
let options = { parse: true }
|
|
const data = await homgot(`${BASE_JIKAN}season/${year}/${type}`, options);
|
|
let body = data.anime;
|
|
const promises = []
|
|
|
|
body.map(doc =>{
|
|
|
|
promises.push({
|
|
title: doc.title,
|
|
malid: doc.mal_id,
|
|
image: doc.image_url,
|
|
genres: doc.genres.map(x => x.name)
|
|
});
|
|
});
|
|
|
|
return promises;
|
|
|
|
};
|
|
|
|
const allSeasons = async () =>{
|
|
|
|
let options = { parse: true }
|
|
const data = await homgot(`${BASE_JIKAN}season/archive`, options);
|
|
let body = data.archive;
|
|
const promises = []
|
|
|
|
body.map(doc =>{
|
|
|
|
promises.push({
|
|
year: doc.year,
|
|
seasons: doc.seasons,
|
|
});
|
|
});
|
|
|
|
return promises;
|
|
|
|
};
|
|
|
|
const laterSeasons = async () =>{
|
|
|
|
let options = { parse: true }
|
|
const data = await homgot(`${BASE_JIKAN}season/later`, options);
|
|
let body = data.anime;
|
|
const promises = []
|
|
|
|
body.map(doc =>{
|
|
|
|
promises.push({
|
|
malid: doc.mal_id,
|
|
title: doc.title,
|
|
image: doc.image_url
|
|
});
|
|
});
|
|
|
|
return promises;
|
|
|
|
};
|
|
|
|
const getLastEpisodes = async () =>{
|
|
|
|
let options = { parse: true }
|
|
const data = await homgot(`${BASE_ANIMEFLV_JELU}LatestEpisodesAdded`, options);
|
|
let body = data.episodes;
|
|
const promises = []
|
|
|
|
body.map(doc => {
|
|
|
|
promises.push(helper().then(async () => ({
|
|
id: doc.id,
|
|
title: doc.title,
|
|
image: doc.poster,
|
|
episode: doc.episode,
|
|
servers: await transformUrlServer(JSON.parse(JSON.stringify(doc.servers)))
|
|
})));
|
|
|
|
});
|
|
|
|
return Promise.all(promises);
|
|
|
|
};
|
|
|
|
const getSpecials = async (type, subType, page) =>{
|
|
|
|
let options = { parse: true }
|
|
const data = await homgot(`${BASE_ANIMEFLV_JELU}${type.url}/${subType}/${page}`, options);
|
|
let body = data[type.prop];
|
|
const promises = []
|
|
|
|
body.map(doc =>{
|
|
|
|
promises.push({
|
|
id: doc.id,
|
|
title: doc.title,
|
|
type: doc.type,
|
|
banner: doc.banner,
|
|
image: doc.poster,
|
|
synopsis: doc.synopsis,
|
|
status: doc.debut,
|
|
rate: doc.rating,
|
|
genres: doc.genres.map(x => x),
|
|
episodes: doc.episodes.map(x => x)
|
|
});
|
|
});
|
|
|
|
return promises;
|
|
|
|
};
|
|
|
|
const getMoreInfo = async (title) =>{
|
|
|
|
const promises = []
|
|
let animeTitle = ''
|
|
let animeId = ''
|
|
let animeType = ''
|
|
let animeIndex = ''
|
|
|
|
let seriesTitle
|
|
let position
|
|
|
|
const jkAnimeTitles = [
|
|
{ title: 'The God of High School', id: 'the-god-of-high-school' },
|
|
{ title: 'Kami no Tou', id: 'kami-no-tou' },
|
|
{ title: 'BNA', id: 'bna' },
|
|
{ title: 'Ansatsu Kyoushitsu (TV)', id: 'ansatsu-kyoushitsu-tv' },
|
|
{ title: 'Ansatsu Kyoushitsu (TV) 2nd Season', id: 'ansatsu-kyoushitsu-tv-2nd-season' }
|
|
];
|
|
|
|
const jkMyAnimetitles = [
|
|
{ jkanime: 'Ansatsu Kyoushitsu (TV)', myanimelist: 'Ansatsu Kyoushitsu'},
|
|
{ jkanime: 'Ansatsu Kyoushitsu (TV) 2nd Season', myanimelist: 'Ansatsu Kyoushitsu 2nd Season' }
|
|
];
|
|
|
|
let jkanime = false
|
|
let jkanimeID
|
|
let jkanimeName
|
|
for (let name in jkAnimeTitles) {
|
|
if (title === jkAnimeTitles[name].title) {
|
|
jkanime = true
|
|
jkanimeID = jkAnimeTitles[name].id
|
|
|
|
for (let name in jkMyAnimetitles) {
|
|
if (title === jkMyAnimetitles[name].jkanime || title === jkMyAnimetitles[name].myanimelist) {
|
|
jkanimeName = jkMyAnimetitles[name].myanimelist
|
|
position = name
|
|
}
|
|
}
|
|
|
|
if (jkanimeName === undefined) {
|
|
jkanimeName = jkAnimeTitles[name].title
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if (jkanime === false) {
|
|
const titles = [
|
|
{ animeflv: 'Kaguya-sama wa Kokurasetai: Tensai-tachi no Renai Zunousen 2nd Season', myanimelist: 'Kaguya-sama wa Kokurasetai?: Tensai-tachi no Renai Zunousen', alternative: 'Kaguya-sama wa Kokurasetai'},
|
|
{ animeflv: 'Naruto Shippuden', myanimelist: 'Naruto: Shippuuden' },
|
|
{ animeflv: 'Rock Lee no Seishun Full-Power Ninden', myanimelist: 'Naruto SD: Rock Lee no Seishun Full-Power Ninden' },
|
|
{ animeflv: 'BAKI: dai reitaisai-hen', myanimelist: 'Baki 2nd Season' },
|
|
{ animeflv: 'Hitoribocchi no ○○ Seikatsu', myanimelist: 'Hitoribocchi no Marumaru Seikatsu' },
|
|
{ animeflv: 'Nekopara (TV)', myanimelist: 'Nekopara' },
|
|
{ animeflv: 'Black Clover (TV)', myanimelist: 'Black Clover' }
|
|
];
|
|
|
|
for (let name in titles) {
|
|
if (title === titles[name].animeflv || title === titles[name].myanimelist || title === titles[name].alternative) {
|
|
seriesTitle = titles[name].animeflv
|
|
position = name
|
|
}
|
|
}
|
|
|
|
|
|
if (seriesTitle === undefined) {
|
|
seriesTitle = title
|
|
}
|
|
|
|
await getAllAnimes().then(animes => {
|
|
|
|
for (const i in animes) {
|
|
if (animes[i].title.split('\t')[0] === seriesTitle.split('\t')[0] ||
|
|
animes[i].title === `${seriesTitle} (TV)` ||
|
|
animes[i].title.includes(seriesTitle.split('○')[0])
|
|
) {
|
|
if (animes[i].title.includes('(TV)', 0)) { animeTitle = animes[i].title.split('\t')[0].replace(' (TV)', '') }
|
|
else { animeTitle = animes[i].title.split('\t')[0] }
|
|
animeId = animes[i].id
|
|
animeIndex = animes[i].index
|
|
animeType = animes[i].type.toLowerCase()
|
|
|
|
if (position !== undefined) {
|
|
seriesTitle = titles[position].myanimelist
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
}
|
|
});
|
|
|
|
try{
|
|
|
|
if (animeType === 'tv') {
|
|
promises.push(await animeflvInfo(animeId, animeIndex).then(async extra => ({
|
|
title: animeTitle || null,
|
|
poster: await imageUrlToBase64(extra.animeExtraInfo[0].poster) || null,
|
|
synopsis: extra.animeExtraInfo[0].synopsis || null,
|
|
status: extra.animeExtraInfo[0].debut || null,
|
|
type: extra.animeExtraInfo[0].type || null,
|
|
rating: extra.animeExtraInfo[0].rating || null,
|
|
genres: extra.genres || null,
|
|
episodes: extra.listByEps || null,
|
|
moreInfo: await animeExtraInfo(seriesTitle).then(info =>{
|
|
return info || null
|
|
}),
|
|
promo: await getAnimeVideoPromo(seriesTitle).then(promo =>{
|
|
return promo || null
|
|
}),
|
|
characters: await getAnimeCharacters(seriesTitle).then(characters =>{
|
|
return characters || null
|
|
})
|
|
})));
|
|
} else {
|
|
promises.push(await animeflvInfo(animeId).then(async extra => ({
|
|
title: animeTitle || null,
|
|
poster: await imageUrlToBase64(extra.animeExtraInfo[0].poster) || null,
|
|
synopsis: extra.animeExtraInfo[0].synopsis || null,
|
|
status: extra.animeExtraInfo[0].debut || null,
|
|
type: extra.animeExtraInfo[0].type || null,
|
|
rating: extra.animeExtraInfo[0].rating || null,
|
|
genres: extra.genres || null,
|
|
episodes: extra.listByEps || null,
|
|
})));
|
|
}
|
|
|
|
}catch(err){
|
|
console.log(err)
|
|
}
|
|
} else {
|
|
promises.push(await jkanimeInfo(jkanimeID).then(async extra => ({
|
|
title: jkanimeName || null,
|
|
poster: await imageUrlToBase64(extra.animeExtraInfo[0].poster) || null,
|
|
synopsis: extra.animeExtraInfo[0].synopsis || null,
|
|
status: extra.animeExtraInfo[0].debut || null,
|
|
type: extra.animeExtraInfo[0].type || null,
|
|
rating: extra.animeExtraInfo[0].rating || null,
|
|
genres: extra.genres || null,
|
|
episodes: extra.listByEps || null,
|
|
moreInfo: await animeExtraInfo(jkanimeName).then(info =>{
|
|
return info || null
|
|
}),
|
|
promo: await getAnimeVideoPromo(jkanimeName).then(promo =>{
|
|
return promo || null
|
|
}),
|
|
characters: await getAnimeCharacters(jkanimeName).then(characters =>{
|
|
return characters || null
|
|
})
|
|
})));
|
|
}
|
|
|
|
return promises;
|
|
|
|
};
|
|
|
|
const getAnimeServers = async (id) => {
|
|
|
|
const jkAnimeIDs = [
|
|
{ id: 'the-god-of-high-school' },
|
|
{ id: 'kami-no-tou' },
|
|
{ id: 'bna' },
|
|
{ id: 'ansatsu-kyoushitsu-tv' },
|
|
{ id: 'ansatsu-kyoushitsu-tv-2nd-season' }
|
|
];
|
|
|
|
let jkanime = false
|
|
let jkanimeID
|
|
for (let name in jkAnimeIDs) {
|
|
if (id.includes(jkAnimeIDs[name].id)) {
|
|
jkanime = true
|
|
jkanimeID = id
|
|
}
|
|
}
|
|
|
|
if (jkanime === false) {
|
|
|
|
let options = { parse: true }
|
|
const data = await homgot(`${BASE_ANIMEFLV_JELU}GetAnimeServers/${id}`, options);
|
|
let body = data.servers;
|
|
|
|
return await transformUrlServer(body);
|
|
|
|
} else {
|
|
return await videoServersJK(jkanimeID)
|
|
}
|
|
|
|
};
|
|
|
|
const search = async (title) =>{ return await searchAnime(title); };
|
|
|
|
const getImages = async (query) => {
|
|
|
|
let options = { parse: true }
|
|
const data = await homgot(`${BASE_QWANT}count=${query.count}&q=${query.title}&t=${query.type}&safesearch=${query.safesearch}&locale=${query.country}&uiv=4`, options);
|
|
const body = data.data.result.items;
|
|
const promises = []
|
|
|
|
body.map(doc =>{
|
|
|
|
promises.push({
|
|
type: doc.thumb_type,
|
|
thumbnail: `https:${doc.thumbnail}`,
|
|
fullsize: `https:${doc.media_fullsize}`
|
|
});
|
|
|
|
});
|
|
|
|
return promises;
|
|
|
|
};
|
|
|
|
const getYoutubeVideos = async (channelId) => {
|
|
|
|
let options = { parse: true }
|
|
const data = await homgot(`${BASE_YOUTUBE}${channelId.id}&part=${channelId.part}&order=${channelId.order}&maxResults=${channelId.maxResults}`, options);
|
|
const body = data[channelId.prop];
|
|
const promises = []
|
|
|
|
body.map(doc =>{
|
|
|
|
promises.push({
|
|
title: doc.snippet.title,
|
|
videoId: doc.id.videoId,
|
|
thumbDefault: doc.snippet.thumbnails.default.url,
|
|
thumbMedium: doc.snippet.thumbnails.medium.url,
|
|
thumbHigh: doc.snippet.thumbnails.high.url
|
|
});
|
|
|
|
});
|
|
|
|
return promises;
|
|
|
|
};
|
|
|
|
const getRadioStations = async () => {
|
|
return require('../assets/radiostations.json');
|
|
}
|
|
|
|
const getOpAndEd = async (title) => {
|
|
let data = await parserThemes.serie(title)
|
|
return await structureThemes(data, true)
|
|
};
|
|
|
|
const getThemesYear = async (year) => {
|
|
let data = []
|
|
|
|
if (year === undefined) {
|
|
return await parserThemes.allYears();
|
|
} else {
|
|
data = await parserThemes.year(year)
|
|
return await structureThemes(data, false)
|
|
}
|
|
|
|
};
|
|
|
|
const getRandomTheme = async () => {
|
|
|
|
let promise = []
|
|
let options = { parse: true }
|
|
const data = await homgot(`${BASE_THEMEMOE}roulette`, options);
|
|
let themes = await getThemes(data.themes)
|
|
|
|
promise.push({
|
|
name: data.name,
|
|
title: themes[0].name,
|
|
link: themes[0].video
|
|
})
|
|
|
|
return promise;
|
|
};
|
|
|
|
const getArtist = async (id) => {
|
|
|
|
let data
|
|
|
|
if (id === undefined) {
|
|
return await parserThemes.artists();
|
|
} else {
|
|
data = await parserThemes.artist(id)
|
|
return await structureThemes(data, false)
|
|
}
|
|
|
|
};
|
|
|
|
const getAnimeGenres = async(genre, order, page) => {
|
|
|
|
let $
|
|
let promises = []
|
|
let options = { scrapy: true }
|
|
|
|
if (page !== undefined) {
|
|
$ = await homgot(`${GENRES_URL}genre%5B%5D=${genre}&order=${order}&page=${page}`,options)
|
|
} else {
|
|
$ = await homgot(`${GENRES_URL}genre%5B%5D=${genre}&order=${order}`,options)
|
|
}
|
|
|
|
|
|
$('div.Container ul.ListAnimes li article').each((index , element) =>{
|
|
const $element = $(element);
|
|
const id = $element.find('div.Description a.Button').attr('href').slice(1);
|
|
const title = $element.find('a h3').text();
|
|
const poster = $element.find('a div.Image figure img').attr('src');
|
|
const banner = poster.replace('covers' , 'banners').trim();
|
|
const type = $element.find('div.Description p span.Type').text();
|
|
const synopsis = $element.find('div.Description p').eq(1).text().trim();
|
|
const rating = $element.find('div.Description p span.Vts').text();
|
|
|
|
promises.push(animeflvGenres(id).then(async genres => ({
|
|
id: id || null,
|
|
title: title || null,
|
|
poster: await imageUrlToBase64(poster) || null,
|
|
banner: banner || null,
|
|
synopsis: synopsis || null,
|
|
type: type || null,
|
|
rating: rating || null,
|
|
genres: genres || null
|
|
})))
|
|
|
|
})
|
|
|
|
return Promise.all(promises);
|
|
|
|
};
|
|
|
|
const getAllThemes = async () => {
|
|
let data = await parserThemes.all()
|
|
return await structureThemes(data, false)
|
|
};
|
|
|
|
module.exports = {
|
|
schedule,
|
|
top,
|
|
getAllAnimes,
|
|
getAllDirectory,
|
|
getAnitakume,
|
|
getNews,
|
|
season,
|
|
allSeasons,
|
|
laterSeasons,
|
|
getLastEpisodes,
|
|
getSpecials,
|
|
getMoreInfo,
|
|
getAnimeServers,
|
|
search,
|
|
getImages,
|
|
getYoutubeVideos,
|
|
getRadioStations,
|
|
getOpAndEd,
|
|
getThemesYear,
|
|
getRandomTheme,
|
|
getArtist,
|
|
getAnimeGenres,
|
|
getAllThemes
|
|
};
|