296 lines
8.1 KiB
JavaScript
296 lines
8.1 KiB
JavaScript
// JD Requires
|
|
let Parser = require('rss-parser');
|
|
const axios = require('axios');
|
|
let parser = new Parser();
|
|
const { FeedStorage, PostStorage } = require("./libStorage");
|
|
const libUtils = require("./libUtils");
|
|
const { createHash } = require("crypto");
|
|
const { all } = require('axios');
|
|
|
|
const { DebugBuilder } = require("./utilities/debugBuilder");
|
|
const log = new DebugBuilder("server", "libCore");
|
|
|
|
// Setup Storage handlers
|
|
var feedStorage = new FeedStorage();
|
|
var postStorage = new PostStorage();
|
|
|
|
/**
|
|
* Adds or updates new source url to configured storage
|
|
* @constructor
|
|
* @param {string} title - Title/Name of the RSS feed.
|
|
* @param {string} link - URL of RSS feed.
|
|
* @param {string} category - Category of RSS feed.
|
|
*/
|
|
exports.addSource = async (title, link, category, guildId, channelId, callback) => {
|
|
feedStorage.create([{
|
|
"fields": {
|
|
"title": title,
|
|
"link": link,
|
|
"category": category,
|
|
'guild_id': guildId,
|
|
"channel_id": channelId
|
|
}
|
|
}], function (err, record) {
|
|
if (err) {
|
|
log.ERROR("Error in create:", err);
|
|
return callback(err, undefined);
|
|
}
|
|
|
|
if (!record) return callback(undefined, false);
|
|
|
|
log.DEBUG("Record ID:", record.getId());
|
|
|
|
return callback(undefined, record);
|
|
});
|
|
|
|
}
|
|
|
|
/**
|
|
* Deletes a new source url by title
|
|
* @constructor
|
|
* @param {string} title - Title/Name of the RSS feed.
|
|
*/
|
|
exports.deleteSource = function (title, callback) {
|
|
feedStorage.getRecordBy('title', title, (err, results) => {
|
|
if (err) return callback(err, undefined);
|
|
|
|
if (!results?.id) {
|
|
log.DEBUG("No record found for title: ", title)
|
|
return callback(undefined, undefined);
|
|
}
|
|
|
|
feedStorage.destroy(results.id, function (err, deletedRecord) {
|
|
if (err) {
|
|
log.ERROR(err);
|
|
return callback(err, undefined);
|
|
}
|
|
log.DEBUG("Deleted Record: ", deletedRecord);
|
|
return callback(undefined, deletedRecord ?? true);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Adds a new source url to configured storage
|
|
* @constructor
|
|
* @param {string} category - Category to select Feed by, defaults to all.
|
|
*/
|
|
exports.getPosts = async (category) => {
|
|
postStorage.getAllRecords((err, results) => {
|
|
if (category == null || category == undefined || category == "" || category.toLowerCase() == "all") {
|
|
if (err) throw err;
|
|
if (results.length > 1)
|
|
return results;
|
|
}
|
|
|
|
var rssFilteredFeed;
|
|
for (const rssFeed of results){
|
|
if (rssFeed.category.toLowerCase() == category.toLowerCase()) {
|
|
rssFilteredFeed.push(rssFeed);
|
|
}
|
|
}
|
|
return rssFilteredFeed;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Update channels with new posts from sources
|
|
*/
|
|
exports.updateFeeds = async (client) => {
|
|
if (!client) throw new Error("Client object not passed");
|
|
feedStorage.getAllRecords((err, records) => {
|
|
// Load the posts from each RSS source
|
|
for (const source of records) {
|
|
log.DEBUG('Record title: ', source.title);
|
|
log.DEBUG('Record link: ', source.link);
|
|
log.DEBUG('Record category: ', source.category);
|
|
log.DEBUG('Record guild ID: ', source.guild_id);
|
|
log.DEBUG('Record channel ID: ', source.channel_id);
|
|
|
|
parser.parseURL(source.link, (err, parsedFeed) => {
|
|
if (err) {
|
|
log.ERROR("Parser Error: ", source.link, err);
|
|
//return;
|
|
}
|
|
|
|
if (parsedFeed?.items){
|
|
for (const post of parsedFeed.items){
|
|
if (post.title && post.link && post.content && post.guid && post.pubDate){
|
|
postStorage.getRecordBy('post_guid', post.guid, (err, results) => {
|
|
if (err) throw err;
|
|
log.DEBUG("Results from asdasdasd: ", results);
|
|
if (!results){
|
|
const channel = client.channels.cache.get(source.channel_id);
|
|
libUtils.sendPost(post, channel, (err, results) =>{
|
|
if (err) throw err;
|
|
|
|
if (results){
|
|
log.DEBUG("Saving post to database: ", results, post.title, source.channel_id);
|
|
|
|
postStorage.savePost(post, (err, results) => {
|
|
if(err) throw err;
|
|
|
|
if (results) {
|
|
log.DEBUG("Saved results: ", results);
|
|
}
|
|
});
|
|
}
|
|
})
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Search a state for any weather alerts
|
|
*
|
|
* @param {*} state The state to search for any weather alerts in
|
|
* @returns
|
|
*/
|
|
exports.weatherAlert = async function (state) {
|
|
|
|
var answerURL = `https://api.weather.gov/alerts/active?area=${state}`;
|
|
log.DEBUG(answerURL);
|
|
answerData = [];
|
|
|
|
await axios.get(answerURL)
|
|
.then(response => {
|
|
response.data.features.forEach(feature => {
|
|
answerData.push(feature);
|
|
})
|
|
|
|
return answerData;
|
|
})
|
|
.catch(error => {
|
|
log.DEBUG(error);
|
|
});
|
|
return answerData;
|
|
}
|
|
|
|
/**
|
|
* Gets a random food recipe
|
|
*
|
|
* @returns
|
|
*/
|
|
exports.getFood = async function () {
|
|
|
|
var answerURL = `https://www.themealdb.com/api/json/v1/1/random.php`;
|
|
log.DEBUG(answerURL);
|
|
answerData = {
|
|
text: `No answer found try using a simpler search term`,
|
|
source: ``
|
|
}
|
|
await axios.get(answerURL)
|
|
.then(response => {
|
|
//log.DEBUG(response.data.RelatedTopics[0].Text);
|
|
//log.DEBUG(response.data.RelatedTopics[0].FirstURL);
|
|
|
|
// if (response.data.meals.length != 0) {
|
|
|
|
answerData = {
|
|
strMeal: `No Data`,
|
|
strSource: `-`,
|
|
strInstructions: `-`,
|
|
strMealThumb: `-`,
|
|
strCategory: `-`
|
|
}
|
|
|
|
answerData = {
|
|
strMeal: `${unescape(response.data.meals[0].strMeal)}`,
|
|
strSource: `${unescape(response.data.meals[0].strSource)}`,
|
|
strInstructions: `${unescape(response.data.meals[0].strInstructions)}`,
|
|
strMealThumb: `${unescape(response.data.meals[0].strMealThumb)}`,
|
|
strCategory: `${unescape(response.data.meals[0].strCategory)}`
|
|
}
|
|
// } else {
|
|
|
|
//}
|
|
return answerData;
|
|
})
|
|
.catch(error => {
|
|
log.DEBUG(error);
|
|
});
|
|
return answerData;
|
|
}
|
|
|
|
/**
|
|
* Search Urban dictionary for a phrase
|
|
*
|
|
* @param {*} question The phrase to search urban dictionary for
|
|
* @returns
|
|
*/
|
|
exports.getSlang = async function (question) {
|
|
|
|
var answerURL = `https://api.urbandictionary.com/v0/define?term=${question}`;
|
|
log.DEBUG(answerURL);
|
|
slangData = {
|
|
definition: `No answer found try using a simpler search term`,
|
|
example: ``
|
|
}
|
|
await axios.get(answerURL)
|
|
.then(response => {
|
|
log.DEBUG(response.data.list[0]);
|
|
|
|
slangData = {
|
|
definition: `${unescape(response.data.list[0].definition) ? unescape(response.data.list[0].definition) : ''}`,
|
|
example: `${unescape(response.data.list[0].example) ? unescape(response.data.list[0].example) : ''}`,
|
|
thumbs_down: `${unescape(response.data.list[0].thumbs_down)}`,
|
|
thumbs_up: `${unescape(response.data.list[0].thumbs_up)}`
|
|
}
|
|
|
|
return slangData;
|
|
})
|
|
.catch(error => {
|
|
log.DEBUG(error);
|
|
});
|
|
return slangData;
|
|
}
|
|
|
|
/**
|
|
* getSources - Get the RSS sources currently in use
|
|
* @constructor
|
|
*/
|
|
exports.getSources = function () {
|
|
feedStorage.getAllRecords((err, records) => {
|
|
if (err) throw err;
|
|
return records;
|
|
})
|
|
}
|
|
|
|
/**
|
|
* getQuotes - Get a random quote from the local list
|
|
* @constructor
|
|
*/
|
|
exports.getQuotes = async function (quote_url) {
|
|
|
|
var data = [];
|
|
await axios.get(quote_url)
|
|
.then(response => {
|
|
log.DEBUG(response.data[0].q);
|
|
log.DEBUG(response.data[0].a);
|
|
data = response.data;
|
|
|
|
return data;
|
|
})
|
|
.catch(error => {
|
|
log.DEBUG(error);
|
|
});
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* getCategories - Returns feed categories
|
|
* @constructor
|
|
*/
|
|
exports.getCategories = async (callback) => {
|
|
feedStorage.getUniqueByKey("category", (err, results) => {
|
|
if (err) return callback(err, undefined);
|
|
|
|
return callback(undefined, results);
|
|
});
|
|
} |