Added CRON

This commit is contained in:
Yessiest 2022-05-08 19:26:52 +04:00
parent c75f53c474
commit 5542ac5ce5
5 changed files with 658 additions and 53 deletions

3
.gitignore vendored
View File

@ -2,5 +2,8 @@
/servers /servers
/discordia.log /discordia.log
/gateway.json /gateway.json
/luvit
/lit
/luvi
*.so *.so
*.o *.o

36
bot.lua
View File

@ -8,27 +8,33 @@ client = discordia.Client()
--activate the import system --activate the import system
local import = require("import")(require) local import = require("import")(require)
local server_ids = {
"640251445949759499"
}
local servers = {} local servers = {}
--create server --create server
local server = import("classes.server-handler") local server = import("classes.server-handler")
client:on("ready",function() client:on("ready",function()
print("starting test") print("starting test")
if not servers["640251445949759499"] then for _,id in pairs(server_ids) do
servers["640251445949759499"] = server(client,client:getGuild("640251445949759499"),{ if not servers[id] then
path = os.getenv("HOME").."/bot-savedata/640251445949759499/", servers[id] = server(client,client:getGuild(id),{
autosave_frequency = 20, path = os.getenv("HOME").."/bot-savedata/"..id.."/",
default_plugins = { autosave_frequency = 20,
"meta", default_plugins = {
"help", "meta",
"plugins", "help",
"esolang", "plugins",
"tools", "esolang",
"reactions", "tools",
"roledefaults", "reactions",
"security" "roledefaults",
} "security",
}) "cron"
}
})
end
end end
end) end)

405
libraries/cron.lua Normal file
View File

@ -0,0 +1,405 @@
-- Lua cron parser
--[[
Copyright © 2022 Yessiest
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the Software), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
]]
-- Adjustments for lua5.1
if _VERSION=="Lua 5.1" then
table.unpack = unpack
end
local cron = {
directive_handler = nil
}
local units = {
m = 60,
h = 60*60,
d = 60*60*24,
y = 60*60*24*356,
w = 60*60*24*7
}
cron.convert_delay = function(str)
local time = os.time()
str:gsub("(%d+)([hmdyw])",function(n,unit)
time = time+(units[unit]*tonumber(n))
end)
return time
end
-- Utility functions
local mdays = {31,28,31,30,31,30,31,31,30,31,30,31}
cron._date = function(d,m,y)
local current_date = os.date("*t")
local y = ("2000"):sub(1,4-tostring(y):len())..tostring(y)
d = tonumber(d or current_date.day)
m = tonumber(m or current_date.month)
y = tonumber(y or current_date.year)
if ((y%4 == 0) and (y%100 ~= 0)) or ((y%100 == 0) and (y%400 == 0)) then
mdays[2] = 29
else
mdays[2] = 28
end
return {
assert((d > 0) and (d <= (mdays[m] or 31)) and d, "Invalid day: "..tostring(d)),
assert(mdays[m] and m, "Invalid month: "..tostring(m)),
y
}
end
cron._time = function(h,m)
local current_date = os.date("*t")
h = tonumber(h or current_date,hour)
m = tonumber(m or current_date.min)
return {
assert((h >= 0) and (h < 24) and h, "Invalid hour: "..tostring(h)),
assert((m >= 0) and (m < 60) and m, "Invalid min: "..tostring(m))
}
end
cron._compare_tables = function(d1,d2)
for k,v in pairs(d1) do
if d2[k] ~= v then
return false
end
end
return true
end
-- Token types, in (regex, type, preprocessor) format
local token_types = {
{"@(%w+)", "directive", function(text)
return text
end},
{"(%d%d)%.(%d%d)%.(%d%d%d?%d?)","date",function(d,m,y)
return cron._date(d,m,y)
end},
{"(%d%d):(%d%d)","time",function(h,m)
return cron._time(h,m)
end},
{"(%d*,.*)", "any_list",function(text)
return function(num)
local status = false
text:gsub("%d*",function(number)
if num == tonumber(number) then
status = true
end
end)
return status
end
end},
{"%*/(%d+)", "any_modulo", function(text)
return function(num)
return (num % tonumber(text) == 0)
end
end},
{"%*", "any", function()
return function()
return true
end
end},
{"%d+", "number", function(text)
return function(num)
return num == tonumber(text)
end
end},
{"^%s*$","spacer", function(text) return text end},
{"%S+","command", function(text) return text end}
}
-- Valid argument matching predicates for directives
local predtypes = {
{"([<>])(=?)(%d*)","comparison",function(lm,eq,number)
local number = tonumber(number)
return function(input)
local input = tonumber(input)
if not input then return false end
return ((eq == "=") and number == input) or
((lm == ">") and number < input) or
((lm == "<") and number > input)
end
end},
{"/([^/]*)/","regex",function(regex)
return function(input)
return (tostring(input):match(regex) ~= nil)
end
end},
{"\"([^\"]*)\"","string",function(str)
return function(input)
return str==tostring(input)
end
end},
{"'([^']*)'","string",function(str)
return function(input)
return str==tostring(input)
end
end},
{"%d+","number",function(number)
return function(input)
return number == tostring(input)
end
end},
{"%*","any",function()
return function()
return true
end
end},
{":","delimiter",function()
return function()
error("Delimiter is not a predicate!")
end
end},
{"%s+","spacer",function()
return function()
error("Spacer is not a predicate!")
end
end},
{"%S+","command", function(text)
return function()
return text
end
end}
}
-- Valid syntactic constructions
local syntax = {
{{"number","number","number","number","number"},"cronjob",
function(min,hour,day,mo,dw,comm)
return function(date)
local status = min(date.min)
status = status and hour(date.hour)
status = status and day(date.day)
status = status and mo(date.month)
status = status and dw(wday)
return status,comm
end
end},
{{"date","time"},"onetime",function(date,time,comm)
local time = os.time({day = date[1], month = date[2], year = date[3],
hour = time[1], min = time[2]
})
return function(cdate)
return os.time(cdate) >= time,comm
end
end},
{{"time","date"},"onetime",function(time,date,comm)
local time = os.time({day = date[1], month = date[2], year = date[3],
hour = time[1], min = time[2]
})
return function(cdate)
return os.time(cdate) >= time,comm
end
end}
}
local find_strings = function(text)
-- Find 2 string delimiters.
-- Partition text into before and after if the string is empty
-- Partition text into before, string and after if the string isn't empty
local strings = {text}
while strings[#strings]:match("[\"'/]") do
local string = strings[#strings]
-- Opening character for a string
local open_pos = string:find("[\"'/]")
local open_char = string:sub(open_pos,open_pos)
if strings[#strings]:sub(open_pos+1,open_pos+1) == open_char then
-- Empty string
local text_before = string:sub(1,open_pos-1)
local text_after = string:sub(open_pos+2,-1)
strings[#strings] = text_before
table.insert(strings,open_char..open_char)
table.insert(strings,text_after)
else
-- Non-empty string
local text_before = string:sub(1,open_pos-1)
local _,closing_position = string:sub(open_pos,-1):find("[^\\]"..open_char)
if not closing_position then
break
else
closing_position = closing_position+open_pos-1
end
local text_string = string:sub(open_pos,closing_position)
local text_after = string:sub(closing_position+1,-1)
strings[#strings] = text_before
table.insert(strings,text_string)
table.insert(strings,text_after)
end
end
for k,v in pairs(strings) do
if v:len() == 0 then
table.remove(strings,k)
end
end
return strings
-- P.S: This one is the best one i've written. Sure it looks clunky, but it
-- does exactly what I expect it to do - handle cases when there are string
-- delimiters inside other strings. Lovely. Also kinda horrifying.
end
local startfrom = function(pos,t)
local newtable = {}
for i = pos,#t do
newtable[i+1-pos] = t[i]
end
return newtable
end
cron._split = function(text)
-- Parse strings
local tokens = {}
text:gsub("(%S*)(%s*)",function(text,padding)
table.insert(tokens,text)
if padding:len() > 0 then
table.insert(tokens,padding)
end
end)
return tokens
end
cron._split_with_strings = function(text)
-- Parse strings
local nt = find_strings(text)
local tokens = {}
for k,v in pairs(nt) do
if not ((v:sub(1,1) == v:sub(-1,-1)) and (v:match("^[\"'/]"))) then
-- Parse space-separated tokens
v:gsub("(%S*)(%s*)",function(text,padding)
table.insert(tokens,text)
if padding:len() > 0 then
table.insert(tokens,padding)
end
end)
else
-- Insert pre-parsed strings into tokens
table.insert(tokens,v)
end
end
return tokens
end
cron.parse_token = function(text)
local token = {text}
for _,pair in pairs(token_types) do
if text:match(pair[1]) then
token.type = pair[2]
token[1] = pair[3](token[1]:match(pair[1]))
return token
end
end
end
cron.parse_directive = function(tokens)
table.remove(tokens,1)
-- Prepare predicate chain
local argmatches = {}
local stop = nil
for k,v in pairs(tokens) do
for _,pair in pairs(predtypes) do
if v:match(pair[1]) then
-- Stop at delimiter
if pair[2] == "delimiter" then
stop = k
break
end
-- Ignore spacers - they're not predicates
if pair[2] ~= "spacer" then
table.insert(argmatches,pair[3](v:match(pair[1])))
end
break
end
end
end
-- We use a delimiter so that command start wouldn't be ambiguous
-- Rather than defining an amount of arguments to directives, we
-- simply allow the directive to match any amount of arguments all times
if not stop then
return false, "Directive arguments should end with a : delimiter"
end
local command = table.concat(startfrom(stop+2,tokens))
-- Return the function that matches against a predicate chain
return function(arguments)
for k,v in pairs(argmatches) do
if not v(arguments[k]) then
return false
end
end
return true, command
end,"directive"
end
cron.parse_generic = function(tokens)
-- Parse tokens
local parsed_tokens = {}
for k,v in pairs(tokens) do
local status,token = pcall(cron.parse_token,v)
if not status then
return false,token
end
table.insert(parsed_tokens,token)
end
-- Match against a syntactic construction
for k,v in pairs(syntax) do
local matches = true
local args = {}
for pos,type in pairs(v[1]) do
-- Remove trailing spacer tokens
while parsed_tokens[pos] and parsed_tokens[pos].type == "spacer" do
table.remove(parsed_tokens,pos)
end
if not parsed_tokens[pos] then
break
end
-- Numbers are a special case because they can be matched
-- by multiple predicates
if type == "number" then
if (parsed_tokens[pos].type ~= "number") and
(not parsed_tokens[pos].type:match("^any")) then
matches = false
break
end
else
if (parsed_tokens[pos].type ~= type) then
matches = false
break
end
end
table.insert(args,parsed_tokens[pos][1])
end
if matches then
-- Calculate cut position
local cut_pos = #v[1]*2+1
local command = table.concat(startfrom(cut_pos,tokens))
args[#args+1] = command
return v[3](table.unpack(args)),v[2]
end
end
return false, "Syntax doesn't match any valid construction"
end
cron.parse_line = function(line)
local tokens = cron._split(line)
local status,first_token = pcall(cron.parse_token,tokens[1])
if not status then
return false,first_token
end
if first_token.type == "directive" then
return cron.parse_directive(cron._split_with_strings(line))
-- ...
else
return cron.parse_generic(tokens)
-- ...
end
end
cron.parse = function(text)
text:gsub("\n.-\n?$",function(line)
cron.parse_line(line)
end)
end
return cron

View File

@ -1,38 +0,0 @@
local class = import("classes.baseclass")
local taskhandler = class("TaskHandler")
local sqlite = import("sqlite3")
-- DB format:
--
-- ID (INT) | event(STR) | args (STR) | date (STR) | command (STR)
-- ---------|------------|------------|------------|--------------
-- 1 | time | NULL |12 30 1 10 | ?echo today is yes day
-- 2 | msg | hi |NULL | ?echo yes hello
--
local exists = function(tab,sv)
for k,v in pairs(tab) do
if v == sv then
return true
end
end
return false
end
function taskhandler:__init(dbpath)
self.db = sqlite.open(dbpath)
local query = self.db:exec("SELECT * FROM sqlite_master;")
if not exists(query.tbl_name,"tasks") then
self.db:exec([[
CREATE TABLE tasks(
ID INTEGER PRIMARY KEY,
event STR,
args STR,
date STR,
command STR
);
]])
end
self.cache = {}
end
function taskhandler:daily_cache()
self.db:

229
plugins/cron/init.lua Normal file
View File

@ -0,0 +1,229 @@
local pluginc = import("classes.plugin")
local command = import("classes.command")
local plugin = pluginc("cron")
local cron = import("cron")
local fake_message = import("fake_message")
local md5 = import("md5")
local events = {
timer = {},
event = {}
}
local exec = function(v,command)
local channel = client:getChannel(v.channel)
if not channel then
log("ERROR","Unable to retrieve timer channel: "..tostring(v.channel))
return
end
local msg = channel:getMessage(v.id)
if not msg then
log("ERROR","Unable to retrieve timer message: "..tostring(v.id))
return
end
command_handler:handle(fake_message(msg,{
delete = function() end,
content = command
}))
end
if not config.events then
config.events = {
timer = {},
event = {message = {}}
}
end
local event = command("event",{
help = {embed={
title = "Add a cron event",
description = "Description coming soon",
fields = {
{name = "Usage:",value = "event ..."},
{name = "Perms:",value = "administrator"},
}
}},
perms = {
"administrator"
},
exec = function(msg,args,opts)
local arg = table.concat(args," ")
local func,functype = cron.parse_line(arg)
if not func then
msg:reply(functype)
return false
end
local hash = md5.sumhexa(arg):sub(1,16)
if functype == "directive" then
local event_name = arg:match("^@(%w+)")
if not events.event[event_name] then events.event[event_name] = {} end
events.event[event_name][hash] = {
func,
channel = tostring(msg.channel.id),
id = tostring(msg.id),
user = tostring(msg.author.id),
type = functype
}
if not config.events.event[event_name] then config.events.event[event_name] = {} end
config.events.event[event_name][hash] = {
arg,
channel = tostring(msg.channel.id),
id = tostring(msg.id),
user = tostring(msg.author.id),
type = functype
}
else
events.timer[hash] = {
func,
channel = tostring(msg.channel.id),
id = tostring(msg.id),
user = tostring(msg.author.id),
type = functype
}
config.events.timer[hash] = {
arg,
channel = tostring(msg.channel.id),
id = tostring(msg.id),
user = tostring(msg.author.id),
type = functype
}
end
return true
end
})
plugin:add_command(event)
local delay = command("delay",{
help = {embed={
title = "Delay a command",
description = "Delay fromat is <number><unit>, where unit is one of the follwing:\n\"h\" - hour,\n\"m\" - minute,\n\"d\" - day,\n\"w\" - week,\n\"y\" - year",
fields = {
{name = "Usage:",value = "delay <delayformat> <command>"},
{name = "Perms:",value = "administrator"},
}
}},
perms = {
"administrator"
},
exec = function(msg,args,opts)
local format = args[1]
table.remove(args,1)
local arg = os.date("%d.%m.%y %H:%M ",cron.convert_delay(format))..table.concat(args," ")
local func,functype = cron.parse_line(arg)
if not func then
msg:reply(functype)
return false
end
local hash = md5.sumhexa(arg):sub(1,16)
events.timer[hash] = {
func,
channel = tostring(msg.channel.id),
id = tostring(msg.id),
user = tostring(msg.author.id),
type = functype
}
config.events.timer[hash] = {
arg,
channel = tostring(msg.channel.id),
id = tostring(msg.id),
user = tostring(msg.author.id),
type = functype
}
return true
end
})
plugin:add_command(delay)
local delay = command("events",{
help = {embed={
title = "View your running events",
description = "nuff said.",
fields = {
{name = "Usage:",value = "events <page>"},
{name = "Perms:",value = "administrator"},
}
}},
perms = {
"administrator"
},
args = {
"number"
},
exec = function(msg,args,opts)
local uevents = {}
local uhashes = {}
local upto = 5*args[1]
for k,v in pairs(config.events.timer) do
if v.user == tostring(msg.author.id) then
table.insert(uevents,v)
table.insert(uhashes,k)
end
if #events == upto then
break
end
end
local stop = false
for k,v in pairs(config.events.event) do
for _,events in pairs(v) do
if v.user == tostring(msg.author.id) then
table.insert(uevents,v)
table.insert(uhashes,k)
end
if #events == upto then
stop = true
break
end
end
if stop then
break
end
end
local message = {embed = {
title = "Your events: ",
description = "",
footer = {
text = "Events "..tostring(upto-4).." - "..tostring(upto)
}
}}
for I = upto-4,upto do
if not uhashes[I] then
break
end
message.embed.description = message.embed.description.."["..uhashes[I].."] `"..uevents[I][1].."`\n"
end
msg:reply(message)
end
})
plugin:add_command(delay)
local timer = discordia.Clock()
timer:on("min",function()
for k,v in pairs(events.timer) do
local status,command = v[1](os.date("*t"))
if status then
exec(v,command)
if v.type == "onetime" then
events.timer[k] = nil
config.events.timer[k] = nil
end
end
end
end)
client:on("messageCreate",function(msg)
local content = msg.content
local user = msg.author.name
for k,v in pairs(events.event.message or {}) do
local status,command = v[1]({content,user})
if status then
exec(v,command)
end
end
for k,v in pairs(events.event.messageOnce or {}) do
local status,command = v[1]({content,user})
events.event.messageOnce[k] = nil
config.events.event.messageOnce[k] = nil
end
end)
timer:start(true)
return plugin