rewrite
Romain J 3 years ago
commit 7eac932a4e
  1. 89
      bot.py
  2. 56
      cogs/API.py
  3. 50
      cogs/Admin.py
  4. 8
      cogs/Logs.py
  5. 4
      cogs/Poll.py
  6. 25
      cogs/Useful.py
  7. 4
      cogs/User.py
  8. 6
      configs/config.cfg.example
  9. 19
      database.py
  10. 3
      requirements.txt
  11. 2
      utils/__init__.py
  12. 6
      utils/functions/__init__.py
  13. 11
      utils/functions/database.py
  14. 24
      utils/functions/extra.py
  15. 30
      utils/functions/lang.py
  16. 17
      utils/models/__init__.py
  17. 36
      utils/models/alias.py
  18. 12
      utils/models/lang.py
  19. 38
      utils/models/poll.py
  20. 27
      utils/models/warn.py

@ -1,5 +1,6 @@
import contextlib
import datetime
import json
import logging
import sys
from collections import deque, Counter
@ -8,12 +9,15 @@ from typing import List
import aiohttp
import discord
import git
import sqlalchemy
from discord.ext import commands
from utils import Config
from utils import Database
from utils import Texts
from utils import Version
from utils.functions import Config
from utils.functions import Texts
from utils.functions import Version
from utils.functions import ContextPlus
from utils.models import metadata, database
description = """
Je suis TuxBot, le bot qui vit de l'OpenSource ! ;)
@ -26,6 +30,7 @@ log = logging.getLogger(__name__)
l_extensions: List[str] = [
'cogs.Admin',
'cogs.API',
'cogs.Help',
'cogs.Logs',
# 'cogs.Monitoring',
@ -37,6 +42,7 @@ l_extensions: List[str] = [
async def _prefix_callable(bot, message: discord.message) -> list:
<<<<<<< HEAD
extras = [bot.cluster.get('Name') + '.']
if message.guild is not None:
if str(message.guild.id) in bot.prefixes:
@ -45,13 +51,25 @@ async def _prefix_callable(bot, message: discord.message) -> list:
bot.config.get("misc", "Separator")
)
)
=======
try:
with open(f'./configs/guilds/{message.guild.id}.json', 'r') as f:
data = json.load(f)
custom_prefix = data['prefixes']
except FileNotFoundError:
custom_prefix = ['']
extras = [bot.cluster.get('Name') + '.']
extras.extend(custom_prefix)
>>>>>>> cce7bb409303e9ad27ef4e5617d0bc9068810f13
return commands.when_mentioned_or(*extras)(bot, message)
class TuxBot(commands.AutoShardedBot):
def __init__(self, database):
def __init__(self, ):
super().__init__(command_prefix=_prefix_callable, pm_help=None,
help_command=None, description=description,
help_attrs=dict(hidden=True),
@ -62,20 +80,22 @@ class TuxBot(commands.AutoShardedBot):
self.socket_stats = Counter()
self.command_stats = Counter()
self.uptime: datetime = datetime.datetime.utcnow()
self._prev_events = deque(maxlen=10)
self.session = aiohttp.ClientSession(loop=self.loop)
self.database = database
self.config = Config('./configs/config.cfg')
self.prefixes = Config('./configs/prefixes.cfg')
self.blacklist = Config('./configs/blacklist.cfg')
self.fallbacks = Config('./configs/fallbacks.cfg')
self.cluster = self.fallbacks.find('True', key='This', first=True)
self.uptime: datetime = datetime.datetime.utcnow()
self._prev_events = deque(maxlen=10)
self.session = aiohttp.ClientSession(loop=self.loop)
self.database, self.metadata = database, metadata
self.engine = sqlalchemy.create_engine(str(self.database.url))
self.metadata.create_all(self.engine)
self.version = Version(*version, pre_release='rc2', build=build)
self.owner: discord.User = discord.User
self.owners: List[discord.User] = []
self.owners_id = [int(owner_id) for owner_id in self.config.get('permissions', 'Owners').split(', ')]
self.owner_id = int(self.owners_id[0])
for extension in l_extensions:
try:
@ -91,9 +111,19 @@ class TuxBot(commands.AutoShardedBot):
log.error(Texts().get("Failed to load extension : ")
+ extension, exc_info=e)
@property
def owner(self):
return self.get_user(self.owner_id)
@property
def owners(self):
return [self.get_user(owner_id) for owner_id in self.owners_id]
async def is_owner(self, user: discord.User) -> bool:
return str(user.id) in self.config.get("permissions", "Owners").split(
', ')
return user in self.owners
async def get_context(self, message, *, cls=None):
return await super().get_context(message, cls=cls or ContextPlus)
async def on_socket_response(self, msg):
self._prev_events.append(msg)
@ -110,9 +140,11 @@ class TuxBot(commands.AutoShardedBot):
"Sorry. This command is disabled and cannot be used."
)
)
elif isinstance(error, commands.CommandOnCooldown):
await ctx.send(str(error))
async def process_commands(self, message: discord.message):
ctx = await self.get_context(message)
ctx: commands.Context = await self.get_context(message)
if ctx.command is None:
return
@ -151,13 +183,6 @@ class TuxBot(commands.AutoShardedBot):
print('-' * 60)
await self.change_presence(**presence)
self.owner = await self.fetch_user(
int(self.config.get('permissions', 'Owners').split(', ')[0])
)
for owner in self.config.get('permissions', 'Owners').split(', '):
self.owners.append(
await self.fetch_user(int(owner))
)
@staticmethod
async def on_resumed():
@ -189,13 +214,13 @@ class TuxBot(commands.AutoShardedBot):
@contextlib.contextmanager
def setup_logging():
try:
logging.getLogger('discord').setLevel(logging.INFO)
logging.getLogger('discord.http').setLevel(logging.WARNING)
logging.getLogger('discord').setLevel(logging.INFO)
logging.getLogger('discord.http').setLevel(logging.WARNING)
log = logging.getLogger()
log.setLevel(logging.INFO)
log = logging.getLogger()
log.setLevel(logging.INFO)
try:
handler = logging.FileHandler(filename='logs/tuxbot.log',
encoding='utf-8', mode='w')
fmt = logging.Formatter('[{levelname:<7}] [{asctime}]'
@ -214,14 +239,12 @@ def setup_logging():
if __name__ == "__main__":
log = logging.getLogger()
print(Texts().get('Starting...'))
bot = TuxBot(Database(Config("./configs/config.cfg")))
app = TuxBot()
try:
with setup_logging():
bot.run()
app.run()
except KeyboardInterrupt:
bot.close()
app.close()

@ -0,0 +1,56 @@
import logging
import discord
from aiohttp import web
from discord.ext import commands
from bot import TuxBot
log = logging.getLogger(__name__)
class API(commands.Cog):
def __init__(self, bot: TuxBot):
self.bot = bot
self.site = web.TCPSite
app = web.Application()
app.add_routes([web.get('/users/{user_id}', self.users)])
self.runner = web.AppRunner(app)
self.bot.loop.create_task(self.start_HTTPMonitoring_server())
async def start_HTTPMonitoring_server(self):
host = self.bot.config.get('API', 'Host')
port = self.bot.config.get('API', 'Port')
print(f"Starting API server on {host}:{port}")
await self.runner.setup()
self.site = web.TCPSite(self.runner, host, port)
await self.site.start()
async def users(self, request):
try:
user = await self.bot.fetch_user(request.match_info['user_id'])
except discord.NotFound:
return web.Response(status=404)
json = {
'id': user.id,
'username': user.name,
'discriminator': user.discriminator,
'avatar': user.avatar,
'default_avatar': user.default_avatar.value,
'bot': user.bot,
'system': user.system,
}
return web.json_response(
json
)
def setup(bot: TuxBot):
bot.add_cog(API(bot))

@ -9,8 +9,8 @@ from discord.ext import commands
from bot import TuxBot
from utils import Texts
from utils import WarnModel, LangModel
from utils import commandExtra, groupExtra
from utils.models import WarnModel
from utils import command_extra, group_extra
log = logging.getLogger(__name__)
@ -65,7 +65,7 @@ class Admin(commands.Cog):
###########################################################################
@groupExtra(name='say', invoke_without_command=True, category='text')
@group_extra(name='say', invoke_without_command=True, category='text')
async def _say(self, ctx: commands.Context, *, content: str):
if ctx.invoked_subcommand is None:
try:
@ -105,7 +105,7 @@ class Admin(commands.Cog):
###########################################################################
@commandExtra(name='ban', category='administration')
@command_extra(name='ban', category='administration')
async def _ban(self, ctx: commands.Context, user: discord.Member, *,
reason=""):
try:
@ -132,7 +132,7 @@ class Admin(commands.Cog):
###########################################################################
@commandExtra(name='kick', category='administration')
@command_extra(name='kick', category='administration')
async def _kick(self, ctx: commands.Context, user: discord.Member, *,
reason=""):
try:
@ -159,7 +159,7 @@ class Admin(commands.Cog):
###########################################################################
@commandExtra(name='clear', category='text')
@command_extra(name='clear', category='text')
async def _clear(self, ctx: commands.Context, count: int):
try:
await ctx.message.delete()
@ -169,7 +169,7 @@ class Admin(commands.Cog):
###########################################################################
@groupExtra(name='react', category='text')
@group_extra(name='react', category='text')
async def _react(self, ctx: commands.Context):
if ctx.invoked_subcommand is None:
await ctx.send_help('react')
@ -203,7 +203,7 @@ class Admin(commands.Cog):
###########################################################################
@groupExtra(name='delete', invoke_without_command=True, category='text')
@group_extra(name='delete', invoke_without_command=True, category='text')
async def _delete(self, ctx: commands.Context, message_id: int):
try:
await ctx.message.delete()
@ -229,12 +229,14 @@ class Admin(commands.Cog):
try:
message: discord.Message = await channel.fetch_message(
message_id)
message_id
)
await message.delete()
except (discord.errors.NotFound, discord.errors.Forbidden):
await ctx.send(
Texts('utils', ctx).get("Unable to find the message"),
delete_after=5)
delete_after=5
)
###########################################################################
@ -242,24 +244,18 @@ class Admin(commands.Cog):
member: discord.Member = False):
await ctx.trigger_typing()
week_ago = datetime.datetime.now() - datetime.timedelta(weeks=6)
if member:
warns = self.bot.database.session \
.query(WarnModel) \
.filter(WarnModel.user_id == member.id,
WarnModel.created_at > week_ago,
WarnModel.server_id == ctx.guild.id) \
.order_by(WarnModel.created_at.desc())
warns = WarnModel.objects.filter(
server_id=str(ctx.guild.id),
user_id=member.id
)
else:
warns = self.bot.database.session \
.query(WarnModel) \
.filter(WarnModel.created_at > week_ago,
WarnModel.server_id == ctx.guild.id) \
.order_by(WarnModel.created_at.desc())
warns = WarnModel.objects.filter(
server_id=str(ctx.guild.id)
)
warns_list = ''
for warn in warns:
for warn in await warns.all():
row_id = warn.id
user_id = warn.user_id
user = await self.bot.fetch_user(user_id)
@ -283,7 +279,7 @@ class Admin(commands.Cog):
self.bot.database.session.add(warn)
self.bot.database.session.commit()
@groupExtra(name='warn', aliases=['warns'], category='administration')
@group_extra(name='warn', aliases=['warns'], category='administration')
async def _warn(self, ctx: commands.Context):
await ctx.trigger_typing()
if ctx.invoked_subcommand is None:
@ -411,7 +407,7 @@ class Admin(commands.Cog):
###########################################################################
@commandExtra(name='language', aliases=['lang', 'langue', 'langage'], category='server')
@command_extra(name='language', aliases=['lang', 'langue', 'langage'], category='server')
async def _language(self, ctx: commands.Context, locale: str):
available = self.bot.database.session \
.query(LangModel.value) \
@ -442,7 +438,7 @@ class Admin(commands.Cog):
###########################################################################
@groupExtra(name='prefix', aliases=['prefixes'], category='server')
@group_extra(name='prefix', aliases=['prefixes'], category='server')
async def _prefix(self, ctx: commands.Context):
if ctx.invoked_subcommand is None:
await ctx.send_help('prefix')

@ -20,7 +20,7 @@ from discord.ext import commands, tasks
from bot import TuxBot
from utils import Texts
from utils import commandExtra
from utils import command_extra
log = logging.getLogger(__name__)
@ -243,7 +243,7 @@ class Logs(commands.Cog):
msg = f'{emoji} `[{dt:%Y-%m-%d %H:%M:%S}] {record.message}`'
await self.webhook.send(msg)
@commandExtra(name='commandstats', hidden=True, category='misc')
@command_extra(name='commandstats', hidden=True, category='misc')
@commands.is_owner()
async def _commandstats(self, ctx, limit=20):
counter = self.bot.command_stats
@ -258,7 +258,7 @@ class Logs(commands.Cog):
await ctx.send(f'```\n{output}\n```')
@commandExtra(name='socketstats', hidden=True, category='misc')
@command_extra(name='socketstats', hidden=True, category='misc')
@commands.is_owner()
async def _socketstats(self, ctx):
delta = datetime.datetime.utcnow() - self.bot.uptime
@ -268,7 +268,7 @@ class Logs(commands.Cog):
await ctx.send(
f'{total} socket events observed ({cpm:.2f}/minute):\n{self.bot.socket_stats}')
@commandExtra(name='uptime', category='misc')
@command_extra(name='uptime', category='misc')
async def _uptime(self, ctx):
uptime = humanize.naturaltime(
datetime.datetime.utcnow() - self.bot.uptime)

@ -10,7 +10,7 @@ from bot import TuxBot
from utils import PollModel, ResponsesModel
from utils import Texts
from utils.functions import emotes as utils_emotes
from utils import groupExtra
from utils import group_extra
log = logging.getLogger(__name__)
@ -205,7 +205,7 @@ class Poll(commands.Cog):
poll.content = json.dumps(content)
self.bot.database.session.commit()
@groupExtra(name='poll', aliases=['sondage'], category='poll')
@group_extra(name='poll', aliases=['sondage'], category='poll')
async def _poll(self, ctx: commands.Context):
if ctx.invoked_subcommand is None:
await ctx.send_help('poll')

@ -23,7 +23,7 @@ from tcp_latency import measure_latency
from bot import TuxBot
from utils import Texts
from utils import commandExtra, groupExtra
from utils import command_extra, group_extra
log = logging.getLogger(__name__)
@ -86,7 +86,7 @@ class Useful(commands.Cog):
###########################################################################
@commandExtra(name='iplocalise', category='network')
@command_extra(name='iplocalise', category='network')
async def _iplocalise(self, ctx: commands.Context, addr, ip_type=''):
addr = re.sub(r'http(s?)://', '', addr)
addr = addr[:-1] if addr.endswith('/') else addr
@ -150,14 +150,7 @@ class Useful(commands.Cog):
###########################################################################
@commands.Cog.listener()
async def on_command_error(self, ctx, error):
if isinstance(error, commands.CommandOnCooldown):
await ctx.send(error)
###########################################################################
@commandExtra(name='getheaders', category='network')
@command_extra(name='getheaders', category='network')
async def _getheaders(self, ctx: commands.Context, addr: str):
if (addr.startswith('http') or addr.startswith('ftp')) is not True:
addr = f"http://{addr}"
@ -187,7 +180,7 @@ class Useful(commands.Cog):
###########################################################################
@commandExtra(name='git', aliases=['sources', 'source', 'github'], category='misc')
@command_extra(name='git', aliases=['sources', 'source', 'github'], category='misc')
async def _git(self, ctx):
e = discord.Embed(
title=Texts('useful', ctx).get('git repo'),
@ -202,7 +195,7 @@ class Useful(commands.Cog):
###########################################################################
@commandExtra(name='quote', category='misc')
@command_extra(name='quote', category='misc')
async def _quote(self, ctx, message_id: discord.Message):
e = discord.Embed(
colour=message_id.author.colour,
@ -224,7 +217,7 @@ class Useful(commands.Cog):
###########################################################################
@commandExtra(name='ping', category='network')
@command_extra(name='ping', category='network')
async def _ping(self, ctx: commands.Context):
start = time.perf_counter()
await ctx.trigger_typing()
@ -242,7 +235,7 @@ class Useful(commands.Cog):
###########################################################################
@commandExtra(name='info', aliases=['about'], category='misc')
@command_extra(name='info', aliases=['about'], category='misc')
async def _info(self, ctx: commands.Context):
proc = psutil.Process()
total, python = self.fetch_info()
@ -325,7 +318,7 @@ class Useful(commands.Cog):
###########################################################################
@commandExtra(name='credits', aliases=['contributors', 'authors'], category='misc')
@command_extra(name='credits', aliases=['contributors', 'authors'], category='misc')
async def _credits(self, ctx: commands.Context):
e = discord.Embed(
title=Texts('useful', ctx).get('Contributors'),
@ -349,7 +342,7 @@ class Useful(commands.Cog):
await ctx.send(embed=e)
###########################################################################
@groupExtra(name='cb', aliases=['cc'], category='misc')
@group_extra(name='cb', aliases=['cc'], category='misc')
@commands.cooldown(1, 5, type=commands.BucketType.user)
async def _cb(self, ctx: commands.Context):
if ctx.invoked_subcommand is None:

@ -5,7 +5,7 @@ from discord.ext import commands
from bot import TuxBot
from utils import AliasesModel
from utils import Texts
from utils import groupExtra
from utils import group_extra
log = logging.getLogger(__name__)
@ -19,7 +19,7 @@ class User(commands.Cog):
###########################################################################
@groupExtra(name='alias', aliases=['aliases'], category='alias')
@group_extra(name='alias', aliases=['aliases'], category='alias')
async def _alias(self, ctx: commands.Context):
if ctx.invoked_subcommand is None:
await ctx.send_help('alias')

@ -17,4 +17,8 @@ ID =
Token =
[misc]
Separator =
Separator =
[API]
Host =
Port =

@ -1,7 +1,5 @@
from utils import Config
from utils.models import Base
from utils import Database
from utils.models.lang import LangModel
import sqlalchemy
from utils.models import database, metadata
import argparse
parser = argparse.ArgumentParser()
@ -9,20 +7,13 @@ parser.add_argument("-m", "--migrate", action="store_true")
parser.add_argument("-s", "--seed", action="store_true")
args = parser.parse_args()
database = Database(Config("./configs/config.cfg"))
if args.migrate:
print("Migrate...")
Base.metadata.create_all(database.engine)
engine = sqlalchemy.create_engine(str(database.url))
metadata.create_all(engine)
print("Done!")
if args.seed:
print('Seeding...')
default = LangModel(key="default", value="fr")
available = LangModel(key="available", value="fr,en")
database.session.add(default)
database.session.add(available)
database.session.commit()
# todo: add seeding
print("Done!")

@ -3,7 +3,8 @@ humanize
git+https://github.com/Rapptz/discord.py@master
jishaku
gitpython
sqlalchemy
orm
asyncpg
psycopg2
configparser
psutil

@ -1,5 +1,3 @@
from .models import *
from utils.functions.config import *
from utils.functions.lang import *
from utils.functions.version import *

@ -0,0 +1,6 @@
from .config import Config
from .database import Database
from .extra import *
from .lang import Texts
from .paginator import *
from .version import Version

@ -1,7 +1,7 @@
from .config import Config
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, session
import sqlalchemy
import databases
class Database:
@ -10,8 +10,7 @@ class Database:
postgresql = 'postgresql://{}:{}@{}/{}'.format(
conf_postgresql.get("Username"), conf_postgresql.get("Password"),
conf_postgresql.get("Host"), conf_postgresql.get("DBName"))
self.engine = create_engine(postgresql, echo=False)
Session = sessionmaker()
Session.configure(bind=self.engine)
self.session: session = Session()
self.database = databases.Database(postgresql)
self.metadata = sqlalchemy.MetaData()
self.engine = sqlalchemy.create_engine(str(self.database.url))

@ -1,20 +1,32 @@
from discord.ext import commands
from utils.functions import Config
class commandsPlus(commands.Command):
class CommandsPlus(commands.Command):
def __init__(self, func, **kwargs):
super().__init__(func, **kwargs)
self.category = kwargs.get("category", 'other')
def commandExtra(*args, **kwargs):
return commands.command(*args, **kwargs, cls=commandsPlus)
class GroupPlus(commands.Group):
def __init__(self, func, **kwargs):
super().__init__(func, **kwargs)
self.category = kwargs.get("category", 'other')
def groupExtra(*args, **kwargs):
class ContextPlus(commands.Context):
async def send(self, content=None, **kwargs):
config = Config('./configs/config.cfg')
content = content.replace(config.get("bot", "Token"), 'Whoops! leaked token')
content = content.replace(config.get("webhook", "Token"), 'Whoops! leaked token')
return await super().send(content, **kwargs)
def command_extra(*args, **kwargs):
return commands.command(*args, **kwargs, cls=CommandsPlus)
def group_extra(*args, **kwargs):
return commands.group(*args, **kwargs, cls=GroupPlus)

@ -1,8 +1,6 @@
import gettext
from .config import Config
from .database import Database
import json
from utils.models.lang import LangModel
from discord.ext import commands
@ -21,18 +19,16 @@ class Texts:
self.locale = lang
@staticmethod
def get_locale(ctx):
database = Database(Config("./configs/config.cfg"))
def get_locale(ctx: commands.Context):
lang = 'fr'
if ctx is not None:
current = database.session\
.query(LangModel.value)\
.filter(LangModel.key == str(ctx.guild.id))
if current.count() > 0:
return current.one()[0]
default = database.session\
.query(LangModel.value)\
.filter(LangModel.key == 'default')\
.one()[0]
return default
try:
with open(f'./configs/guilds/{ctx.guild.id}.json', 'r') as f:
data = json.load(f)
lang = data['lang']
except FileNotFoundError:
pass
return lang

@ -1,7 +1,18 @@
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
import databases
import sqlalchemy
from utils.functions import Config
conf_postgresql = Config('./configs/config.cfg')["postgresql"]
postgresql = 'postgresql://{}:{}@{}/{}'.format(
conf_postgresql.get("Username"), conf_postgresql.get("Password"),
conf_postgresql.get("Host"), conf_postgresql.get("DBName"))
database = databases.Database(postgresql)
metadata = sqlalchemy.MetaData()
engine = sqlalchemy.create_engine(str(database.url))
metadata.create_all(engine)
from .lang import LangModel
from .warn import WarnModel
from .poll import PollModel, ResponsesModel
from .alias import AliasesModel

@ -1,28 +1,14 @@
from sqlalchemy import Column, String, BigInteger, Integer
import orm
from . import database, metadata
from . import Base
class AliasesModel(Base):
class AliasesModel(orm.Model):
__tablename__ = 'aliases'
id = Column(Integer, primary_key=True)
user_id = Column(BigInteger)
alias = Column(String)
command = Column(String)
guild = Column(String)
def __repr__(self):
return "<AliasesModel(" \
"id='%s', " \
"user_id='%s', " \
"alias='%s', " \
"command='%s', " \
"guild='%s', " \
")>" % (
self.id,
self.user_id,
self.alias,
self.command,
self.guild
)
__database__ = database
__metadata__ = metadata
id = orm.Integer(primary_key=True)
user_id = orm.String(max_length=18)
alias = orm.String(max_length=255)
command = orm.String(max_length=255)
guild = orm.String(max_length=255)

@ -1,12 +0,0 @@
from . import Base
from sqlalchemy import Column, String
class LangModel(Base):
__tablename__ = 'langs'
key = Column(String, primary_key=True)
value = Column(String)
def __repr__(self):
return "<LangModel(key='%s', locale='%s')>" % (self.key, self.value)

@ -1,27 +1,29 @@
from . import Base
from sqlalchemy import Column, Integer, BigInteger, JSON, ForeignKey, Boolean
from sqlalchemy.orm import relationship
import orm
from . import database, metadata
class PollModel(Base):
__tablename__ = 'polls'
class ResponsesModel(orm.Model):
__tablename__ = 'responses'
__database__ = database
__metadata__ = metadata
id = Column(Integer, primary_key=True, autoincrement=True)
channel_id = Column(BigInteger)
message_id = Column(BigInteger)
id = orm.Integer(primary_key=True)
user = orm.String(max_length=18)
content = Column(JSON)
is_anonymous = Column(Boolean)
choice = orm.Integer()
available_choices = Column(Integer)
choice = relationship("ResponsesModel")
class PollModel(orm.Model):
__tablename__ = 'polls'
__database__ = database
__metadata__ = metadata
class ResponsesModel(Base):
__tablename__ = 'responses'
id = orm.Integer(primary_key=True)
channel_id = orm.String(max_length=18)
message_id = orm.String(max_length=18)
id = Column(Integer, primary_key=True, autoincrement=True)
user = Column(BigInteger)
content = orm.JSON()
is_anonymous = orm.Boolean()
poll_id = Column(Integer, ForeignKey('polls.id'))
choice = Column(Integer)
available_choices = orm.Integer()
choice = orm.ForeignKey(ResponsesModel)

@ -1,19 +1,14 @@
import datetime
import orm
from . import database, metadata
from . import Base
from sqlalchemy import Column, Integer, String, BIGINT, TIMESTAMP
class WarnModel(Base):
class WarnModel(orm.Model):
__tablename__ = 'warns'
id = Column(Integer, primary_key=True)
server_id = Column(BIGINT)
user_id = Column(BIGINT)
reason = Column(String)
created_at = Column(TIMESTAMP, default=datetime.datetime.now())
def __repr__(self):
return "<WarnModel(server_id='%s', user_id='%s', reason='%s', " \
"created_at='%s')>" \
% (self.server_id, self.user_id, self.reason, self.created_at)
__database__ = database
__metadata__ = metadata
id = orm.Integer(primary_key=True)
server_id = orm.String(max_length=18)
user_id = orm.String(max_length=18)
reason = orm.String(max_length=255)
created_at = orm.DateTime()

Loading…
Cancel
Save