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.db import dbmanager
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)
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.orm import relation
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)
from twisted.words.protocols.jabber import xmlstream
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")
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()
