class TestServerAccount(unittest.TestCase):
def setUp(self):
self.db = Database()
self.db.connect()
def tearDown(self):
self.db.close()
def test_init(self):
account = Account(self.db)
self.assertIsInstance(account, Account)
account2 = Account(self.db, 1)
self.assertIsInstance(account, Account)
def test_exists(self):
account = Account(self.db, 123)
account.destroy()
self.assertFalse(account.exists())
account.create()
self.assertTrue(account.exists())
def test_destroy(self):
account = Account(self.db, 123)
account.create()
self.assertTrue(account.exists())
account.destroy()
self.assertFalse(account.exists())
def test_create(self):
account = Account(self.db)
self.assertFalse(account.exists())
accountId = account.create()
cursor = self.db.connection.cursor()
cursor.execute("SELECT id FROM bitcoin.accounts WHERE id = %s LIMIT 1",
[accountId])
self.assertIsNotNone(cursor.fetchone())
def test_update(self):
account = Account(self.db)
accountId = account.create()
self.assertTrue(account.balanceBitcoins == 0.0)
account.balanceBitcoins = 543.0
account.update()
account2 = Account(self.db, accountId)
self.assertTrue(account2.balanceBitcoins == 543.0)
def test_create_update_fetch_init(self):
account = Account(self.db)
self.assertIsInstance(account.create(), int)
account.balanceBitcoins = 123.0
account.update()
account.fetch()
self.assertTrue(account.balanceBitcoins == 123.0)
# create new instance and test it
self.assertTrue(
Account(self.db, account.accountId).balanceBitcoins == 123.0)
def main():
"""Main Irads function.
Sets everything up and launches our application
"""
# Set up CherryPy config
current_dir = os.path.dirname(os.path.abspath(__file__))
# Static directories for serving up various files
conf = {'/': {'tools.staticdir.root': current_dir,
'tools.sessions.on': True,
'tools.sessions.storage_type': "ram",
'tools.sessions.timeout': 3600
},
'/css':
{'tools.staticdir.on': True, 'tools.staticdir.dir': 'css'},
'/docs':
{'tools.staticdir.on': True, 'tools.staticdir.dir': 'docs/html'},
'/js':
{'tools.staticdir.on': True, 'tools.staticdir.dir': 'js'}}
# Set up IP address and port
cherrypy.config.update({'server.socket_host': config.IP,
'server.socket_port': config.PORT})
# Connect to the database
database = Database(connect=True)
database.connect(
config.DATABASE_USERNAME, config.DATABASE_PASSWORD,
config.DATABASE_HOSTNAME, config.DATABASE)
# Set up CherryPy mapping
Mapping = Irads()
Mapping.analysis = IradsAnalysis()
Mapping.manager = IradsManager()
Mapping.report = IradsReport()
Mapping.search = IradsSearch()
Mapping.upload = IradsUpload()
# Start
cherrypy.quickstart(Mapping, '/', config=conf)
from tabulate import tabulate
from database.database import Database
from models.player import Player
# Open the connection to the database
database = Database.connect('mlb.db')
def printPlayers():
players = database.player.getPlayers()
count = -1
table = []
for jugador in (players):
count += 1
table.append([count, *jugador.print()])
print(tabulate(table, headers=["position", "NAME", "AGE"],
tablefmt="grid"))
class MusiciansDBApp(npyscreen.NPSAppManaged):
def __init__(self, *args, **keywords):
super().__init__(*args, **keywords)
self.database = Database('127.0.0.1', 'postgres')
def onStart(self):
self.database.connect('postgres', '1')
self.fill_database()
self.addForm("MAIN", MainList.MainListDisplay, title='Main menu')
self.addForm("MUSICIANSLIST",
MusiciansList.MusiciansListDisplay,
title='Musicians')
self.addForm("MUSICIANEDIT", MusicianEdit.MusicianEdit)
self.addForm("RELEASESLIST", ReleasesList.ReleasesListDisplay)
self.addForm("RELEASEEDIT", ReleaseEdit.ReleaseEdit)
self.addForm("LISTENERSLIST", ListenersList.ListenersListDisplay)
self.addForm("LISTENEREDIT", ListenerEdit.ListenerEdit)
self.addForm("SUBSCRIBE_TO_RELEASE",
SubscribeToRelease.SubscribeToRelease)
self.addForm("SEARCH_STATUS", SearchStatus.SearchStatus)
self.addForm("SEARCH_VIDEO", SearchVideo.SearchVideo)
self.addForm("FULLTEXT_SEARCH", FulltextSearch.FulltextSearch)
def onCleanExit(self):
self.database.close()
def fill_database(self):
self.database.create_musicians_table()
self.database.create_releases_table()
self.database.create_listeners_table()
self.database.create_listeners_releases_table()
patokaband = Musician(name='Patoka',
status=Status.BAND.value,
members=["Skiper", "Kovalski", "Rico"])
sportband = Musician(name='Lets sport',
status=Status.BAND.value,
members=["Skiper", "Kovalski", "Private"])
sportsband = Musician(
name='sports',
status=Status.ORCHESTRA.value,
members=["Skiper", "Kovalski", "Rico", "Private"])
sportsportsport = Musician(
name='sport sport sport',
status=Status.BAND.value,
members=["sportsman1", "sportsman2", "sportsman3"])
release1 = Release(name='Release1',
date=datetime.datetime(year=1999, month=1, day=7),
style="Pop",
is_video=True,
musician_id=3)
release2 = Release(name='Release2',
date=datetime.datetime(year=2018, month=1, day=7),
style="Garage rock",
is_video=False,
musician_id=1)
release3 = Release(name='Release3',
date=datetime.datetime(year=2018, month=1, day=7),
style="Rock",
is_video=False,
musician_id=3)
listener1 = Listener(name='Anna Siryk',
services=["soundcloud", "bandcamp"])
listener2 = Listener(name='Simple Listener',
services=["soundcloud", "vk"])
listener3 = Listener(name='Listener3', services=["soundcloud"])
self.database.create_new_musician(patokaband)
self.database.create_new_musician(sportband)
self.database.create_new_musician(sportsband)
self.database.create_new_musician(sportsportsport)
# self.database.generate_random_musicians(100)
self.database.create_new_release(release1)
self.database.create_new_release(release2)
self.database.create_new_release(release3)
self.database.create_new_listener(listener1)
self.database.create_new_listener(listener2)
self.database.create_new_listener(listener3)
self.database.add_listener_release(1, 1)
self.database.add_listener_release(2, 1)
self.database.add_listener_release(1, 2)
class RESTServer(object):
""" The rest server itself """
def __init__(self):
""" Initialise servers, regexes """
english = Dictionary.get_language(Dictionary.ENGLISH)
logging.basicConfig(filename=os.path.join(__here__, english.get("_server_log_")),
level=logging.DEBUG)
self.__database = Database(os.path.join(__here__, english.get("_server_db_")))
self.__server = responder.Responder()
def __call__(self, env, start_response):
""" Entry point """
database = None
user = None
response = responder.Response()
# First' check for session cookie
try:
database = self.__database.connect()
if "HTTP_COOKIE" in env:
#args = post_parser.parse(data=env["HTTP_COOKIE"])
#if args:
cookies = cookie.Cookie.restore(env["HTTP_COOKIE"])
for c in cookies:
#cookie = cookie.Cookie(client_string = env["HTTP_COOKIE"])
user = database.users().find_session(c)
if user:
logging.debug(user)
break
# # Check there is a valid path
# path = env["PATH_INFO"]
# if path[0:len(self.__root)] != self.__root:
# logging.error("Can't handle this path!")
# response.set_status_code(response.BAD_REQUEST)
# return
path = env["PATH_INFO"][1:].split("/")
# Special paths: "", "favicon.ico", "sitemap.xml", "robots.txt"
special = ["favicon.ico", "sitemap.xml", "robots.txt"]
if len(path) == 1 and path[0] in special:
path.append(path[0])
path[0] = "static"
# if not path[1]:
# path[1] = "index.html"
# if path[1].endswith(".html"):
# response.set_body(html_format_file("protein", protein_name.upper()), "text/html")
# return response
try:
logging.debug("Now serving " + str(path))
if len(path) == 1:
if not path[0]:
path[0] = "index.html"
if path[0].endswith(".html"):
response.set_html(path[0], user)
else:
module = importlib.import_module("server." + path[0])
factory = getattr(module, path[0].title())
server = factory()
response = server.serve(env, path, user, database)
assert response
finally:
pass
except Exception as exc:
logging.error("Exception in main: " + str(exc))
logging.error(traceback.format_exc())
logging.error("--------")
finally:
response.finalise(user)
logging.debug(response.get_status_code())
if database:
database.close()
return self.__server.serve(start_response, response)
def test_connect(self):
db = Database()
db.connect()
self.assertIsNotNone(db.connection)
self.assertIsNotNone(db.connection.cursor())
def test_getSampleData(self):
db = Database()
db.connect()
self.assertIsNotNone(db.getSampleData())
def test_close(self):
db = Database()
db.connect()
db.close()
import yaml
import json
import urllib.request
import time
from wallet import Wallet
from database.database import Database
config = yaml.safe_load(open("config.yml"))
db = Database()
db.connect()
walletBitcoin = 0.0
cash_wallet = Wallet()
firstrun = True
transection = 0.002
print ('Starting simulator...')
def getMidPrice():
with urllib.request.urlopen('https://api.bitfinex.com/v1/pubticker/btcusd') as response:
html = response.read()
return float(json.loads(html)['mid'])
def getSellPrice():
with urllib.request.urlopen('https://api.bitfinex.com/v1/pubticker/btcusd') as response:
html = response.read()
return float(json.loads(html)['last_price'])
oldPrice = currentPrice = initPrice = getSellPrice()
class Bot(Client):
def __init__(self):
Client.__init__(self)
self.utils = Utils()
self.timeout = Timeout()
self.send = self.utils.send
self.modules = self.utils.get_modules_info()
self.config = self.utils.get_config_info()
self.start_time = self.utils.time_now()
self.say = self.send_message
return
def start_bot(self):
try:
try:
self.database = Database()
self.database.connect()
except Exception as e:
self._quit("Database connection error!")
return
# TODO MAKE BEETER
self.loop.run_until_complete(self.start(self.config.bot.token))
except KeyboardInterrupt:
self._cleanup()
finally:
sys.stdout.write("Bot has been closed\n")
return
async def on_ready(self):
self.send(1, "Logged in as: {}".format(self.user.name))
self.send(1, "Client ID: {}".format(self.user.id))
self.send(1, "Listening to the chat!")
return
def _quit(self, msg=""):
sys.exit(msg + "\n")
def _cleanup(self):
try:
self.loop.run_until_complete(self.logout())
self.database.close()
self.database.dispose()
except:
pass
finally:
pending = asyncio.Task.all_tasks()
gathered = asyncio.gather(*pending)
try:
gathered.cancel()
self.loop.run_until_complete(gathered)
gathered.exception()
except:
pass
finally:
self.loop.close()
def restart_bot(self):
try:
self._cleanup()
except:
self._quit("error restarting the bot")
finally:
self.start_bot()
async def on_member_join(self, member):
server_exists = self.database.server.exists(member.server.id)
if not server_exists:
self.database.server.add(member.server.id)
server_info = self.database.server.get(member.server.id)
if server_info.welcome_channel != None:
channel = self.get_channel(server_info.welcome_channel)
letter = server_info.welcome_message
if letter != "":
await self.send_message(channel,
letter.format(member.name,
member.server.name)
) #{0=username} {1=servername}
if server_info.welcome_private:
letter = server_info.welcome_private_message
if letter != "":
await self.send_message(member, letter.format(member.name)
) #{0=username}
return
async def on_member_remove(self, member):
server_info = self.database.server.get_from_server_aut_add(
member.sesrver)
name = self.utils.author_nickanme(member)
if server_info.goodbye_channel != None:
channel = self.get_channel(server_info.goodbye_channel)
letter = server_info.goodbye_message
if letter != "":
await self.send_message(
channel,
letter.format(member.name, member.nick, name,
member.server.name)
) #{0=username} {1=usernick} {2=nick then name}{3=servername}
return
async def on_member_update(self, before, after):
if before.nick != after.nick:
self.send(1, "Adding nick for {}".format(before.name))
self.database.nickname.add(before.id, before.nick, after.nick)
if (before.game != after.game) or (before.status != after.status):
try:
game_before = before.game.name
except:
game_before = ""
try:
game_after = after.game.name
except:
game_after = ""
try:
game_type = after.game.type
except:
game_type = 0
self.send(1, "Updating game for {}".format(before.name))
self.database.status.add(after.id, game_before, game_after,
game_type, str(before.status),
str(after.status))
return
async def on_message_delete(self, message):
self.database.message.delete(message)
return
async def on_message_edit(self, before, after):
return
async def get_module(self, module_name):
for module in self.modules:
if module_name == module.call or module_name in module.aliases:
return module
async def filter_module(self, message, server_stats):
if not message.content.startswith(server_stats.command_start):
return
content = message.content.replace(server_stats.command_start, "", 1)
try:
command, args = content.split(" ", 1)
except:
command = content
args = None
finally:
class_name_, arguments = "", []
# Check if cd, if not -> add
if await self.timeout.user_cmd_check_add(message.author.id, command):
return
module = await self.get_module(command)
if module is None:
class_name_ = "GetCommand"
arguments = command
else:
if module.owner:
if message.author.id != message.server.owner.id:
return
class_name_ = module.class_name
if module.args.delimeter is None:
if args != None:
arguments.append(args)
if not (len(arguments) in module.args.length):
return
elif module.args.delimeter is not None:
if args:
arguments.extend(
args.split(module.args.delimeter, module.args.split))
if len(arguments) not in module.args.length:
return
class_ = getattr(modules, class_name_)()
await class_.main(self, self.database, message, arguments)
await asleep(self.database.cache.botinfo.module_timeout)
await self.timeout.user_cmd_remove(message.author.id, command)
async def on_message(self, message):
"""Doesn't really like private messages yet, actually not at all"""
name = self.utils.author_nickanme(message.author)
self.send(1, "{} > {}".format(name, message.content))
self.database.message.add(message)
if message.channel.is_private:
#TODO ADD HELP MODULE HERE
return
user_stats = self.database.user.get_from_msg_aut_add(message)
server_stats = self.database.server.get_from_server_aut_add(
message.server)
bot_stats = self.database.bot.get()
if message.content.startswith(server_stats.command_start):
points_amount = randint(bot_stats.cmd_point_min,
bot_stats.cmd_point_max)
xp_amount = randint(bot_stats.cmd_xp_min, bot_stats.cmd_xp_max)
else:
points_amount = randint(bot_stats.msg_point_min,
bot_stats.msg_point_max)
xp_amount = randint(bot_stats.msg_xp_min, bot_stats.msg_xp_max)
messages_active = await self.timeout.check_user_msg(message.author.id)
if not messages_active:
self.database.user.points_alter(message.author.id, points_amount)
self.database.user.xp_alter(message.author.id, xp_amount)
await self.timeout.user_msg(message.author.id)
levels = self.utils.level_check(message.author.id, user_stats.xp,
user_stats.level,
bot_stats.level_base_xp,
bot_stats.level_scaling_xp,
bot_stats.level_scaling_max)
if levels.set_level:
self.database.user.level_alter(message.author.id, 1)
if server_stats.post_level:
letter = server_stats.post_level_msg
if server_stats.post_level_same_channel_as_msg:
await self.send_message(
message.channel, letter.format(name, levels.new_level))
else:
channel = self.get_channel(server_info.post_info_channel)
await self.send_message(
channel, letter.format(name, levels.new_level))
if message.author.id == self.user.id:
return
await self.filter_module(message, server_stats)
return
class RESTServer(object):
""" The rest server itself """
def __init__(self):
""" Initialise servers, regexes """
english = Dictionary.get_language(Dictionary.ENGLISH)
logging.basicConfig(filename=os.path.join(__here__,
english.get("_server_log_")),
level=logging.DEBUG)
self.__database = Database(
os.path.join(__here__, english.get("_server_db_")))
self.__server = responder.Responder()
def __call__(self, env, start_response):
""" Entry point """
database = None
user = None
response = responder.Response()
# First' check for session cookie
try:
database = self.__database.connect()
if "HTTP_COOKIE" in env:
#args = post_parser.parse(data=env["HTTP_COOKIE"])
#if args:
cookies = cookie.Cookie.restore(env["HTTP_COOKIE"])
for c in cookies:
#cookie = cookie.Cookie(client_string = env["HTTP_COOKIE"])
user = database.users().find_session(c)
if user:
logging.debug(user)
break
# # Check there is a valid path
# path = env["PATH_INFO"]
# if path[0:len(self.__root)] != self.__root:
# logging.error("Can't handle this path!")
# response.set_status_code(response.BAD_REQUEST)
# return
path = env["PATH_INFO"][1:].split("/")
# Special paths: "", "favicon.ico", "sitemap.xml", "robots.txt"
special = ["favicon.ico", "sitemap.xml", "robots.txt"]
if len(path) == 1 and path[0] in special:
path.append(path[0])
path[0] = "static"
# if not path[1]:
# path[1] = "index.html"
# if path[1].endswith(".html"):
# response.set_body(html_format_file("protein", protein_name.upper()), "text/html")
# return response
try:
logging.debug("Now serving " + str(path))
if len(path) == 1:
if not path[0]:
path[0] = "index.html"
if path[0].endswith(".html"):
response.set_html(path[0], user)
else:
module = importlib.import_module("server." + path[0])
factory = getattr(module, path[0].title())
server = factory()
response = server.serve(env, path, user, database)
assert response
finally:
pass
except Exception as exc:
logging.error("Exception in main: " + str(exc))
logging.error(traceback.format_exc())
logging.error("--------")
finally:
response.finalise(user)
logging.debug(response.get_status_code())
if database:
database.close()
return self.__server.serve(start_response, response)
