from core.settings import PluginConfig
import logging
import string
import sbutil
config = PluginConfig('logging')
path = config.getOption('Config', 'path', 'repositories/home/data/logs/python.log')
level = config.getOption('Config', 'level', 'error')
del config
LEVELS = {'debug': logging.DEBUG,
'info': logging.INFO,
'warning': logging.WARNING,
'error': logging.ERROR,
'critical': logging.CRITICAL}
sbutil.enshure_file(path)
logging.basicConfig(
filename = path,
format = '%(levelname)-10s %(asctime)s %(module)s: %(message)s',
level = LEVELS[level])
from core.settings import PluginConfig
from core.net import ipLongToString, ipStringToLong
from core.timers import addTimer
from sqlalchemy import Column, Integer, String, Boolean, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
from core.ui import info, notice
from core.colors import colordict
from core.events import eventHandler, policyHandler
import time, string
import logging
import sauerbomber
config = PluginConfig('bans')
ban_message = config.getOption('Config', 'message', 'Banning ${orange}${name}${white} for $seconds seconds for ${red}${reason}')
del config
ban_message = string.Template(ban_message)
Base = declarative_base()
session = dbmanager.session()
class Ban(Base):
__tablename__='bans'
id = Column(Integer, primary_key=True)
ip = Column(Integer, index=True)
expiration = Column(Integer, index=True) # Epoch seconds
reason = Column(String)
nick = Column(String)
banner_ip = Column(Integer)
banner_nick = Column(String)
def __init__(self, uri):
self.uri = uri
self.isConnected = False
def connect(self):
if not self.isConnected:
self.engine = create_engine(self.uri, echo=False)
self.isConnected = True
self.m_session = sessionmaker(bind=self.engine, autocommit=False, autoflush=False)()
def reconnect(self):
self.isConnected = False
del self.m_session
del self.engine
self.connect()
def session(self):
return self.m_session
def query(self, *args, **kwargs):
try:
q = self.session().query(*args, **kwargs)
except (OperationalError, InvalidRequestError):
self.reconnect()
q = self.session().query(*args, **kwargs)
return q
config = PluginConfig('db')
uri = config.getOption('Config', 'uri', 'sqlite:///sauerbomber.db')
del config
dbmanager = DatabaseManager(uri)
dbmanager.connect()
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
import sauerbomber
from core.db import dbmanager
from core.events import eventHandler, triggerServerEvent, registerServerEventHandler, registerPolicyEventHandler
#from server.commands import commandHandler, UsageError, StateError, ArgumentValueError
from core.colors import red, green, orange
from core.ui import info, error, warning
# from ..players import player
from core.settings import PluginConfig
from server.users.ban import ban
from core.timers import addTimer
import re
config = PluginConfig('usermanager')
usertable = config.getOption('Config', 'users_tablename', 'usermanager_users')
nicktable = config.getOption('Config', 'linkednames_table', 'usermanager_nickaccounts')
blocked_names = config.getOption('Config', 'blocked_names', 'unnamed, admin')
del config
blocked_names = blocked_names.strip(' ').split(',')
Base = declarative_base()
session = dbmanager.session()
class User(Base):
__tablename__ = usertable
id = Column(Integer, primary_key=True)
email = Column(String, index=True)
password = Column(String, index=True)
def __init__(self, email, password):
from twisted.words.protocols.jabber.xmlstream import XmlStreamFactory, XmlStream
from twisted.words.protocols.jabber import client, jid
from twisted.words.xish import domish
from twisted.internet import reactor
from core.events import registerServerEventHandler
import logging
import sauerbomber
from core.settings import PluginConfig
# from core.commands import commandHandler
import logging
config = PluginConfig("jabber")
jabber_enable = config.getOption("Jabber", "enable", "no") == "yes"
jabber_server = config.getOption("Jabber", "server", "server.com")
jabber_port = config.getOption("Jabber", "port", "5222")
jabber_id = config.getOption("Jabber", "jid", "*****@*****.**")
jabber_pass = config.getOption("Jabber", "password", "pass")
jabber_alerts = config.getOption("Jabber", "alert_accounts", "[email protected], [email protected]")
del config
jabber_port = int(jabber_port)
jabber_id += "/sauerbomber"
jabber_alerts = jabber_alerts.strip().split(",")
class JabberClient(XmlStream):
def connectionMade(self):
logging.debug("Connected")
self.addObserver(xmlstream.STREAM_AUTHD_EVENT, self.authenticated)
import sauerbomber
from core.colors import colordict
from core.settings import PluginConfig
import string
config = PluginConfig('ui')
notice_pre = config.getOption('Prefixes', 'notice', '${blue}Notice:')
info_pre = config.getOption('Prefixes', 'info', '${yellow}Info:')
warning_pre = config.getOption('Prefixes', 'warning', '${red}Warning:')
error_pre = config.getOption('Prefixes', 'error', '${red}Error:')
del config
notice_pre = string.Template(notice_pre).substitute(colordict) + ' '
info_pre = string.Template(info_pre).substitute(colordict) + ' '
warning_pre = string.Template(warning_pre).substitute(colordict) + ' '
error_pre = string.Template(error_pre).substitute(colordict) + ' '
def notice(message):
return notice_pre + message
def info(message):
return info_pre + message
def warning(message):
return warning_pre + message
def error(message):
return error_pre + message
def insufficientPermissions(cn):
sauerbomber.playerMessage(cn, error('Insufficient permissions'))
import sauerbomber
from sqlalchemy import Column, Integer, String, Boolean, ForeignKey
from sqlalchemy.orm import relation
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm.exc import NoResultFound
from core.events import registerServerEventHandler
from core.ui import error, info, insufficientPermissions
from core.colors import colordict
from core.settings import PluginConfig
from core.db import dbmanager
import string
config = PluginConfig('userprivilege')
tablename = config.getOption('Config', 'tablename', 'userprivileges')
authtemp = config.getOption('Messages', 'authenticated', '${green}${name}${white} authenticated as ${magenta}${authname}')
gmtemp = config.getOption('Messages', 'gain_master', '${green}${name}${white} claimed ${red}master')
gatemp = config.getOption('Messages', 'gain_admin', '${green}${name}${white} claimed ${red}admin')
rmtemp = config.getOption('Messages', 'release_master', '${green}${name}${white} relinquished ${red}master')
ratemp = config.getOption('Messages', 'release_admin', '${green}${name}${white} relinquished ${red}admin')
del config
authtemp = string.Template(authtemp)
gmtemp = string.Template(gmtemp)
gatemp = string.Template(gatemp)
rmtemp = string.Template(rmtemp)
ratemp = string.Template(ratemp)
Base = declarative_base()
session = dbmanager.session()
