def test_add_player(self):
slack_client = MockSlackClient()
manager = TeamManager(Chat(slack_client, 'foo'))
manager.add_player(Player("p1", slack_client))
self.assertEqual(1, len(manager.players))
self.assertEqual("You have joined the game!", slack_client.api_calls[-1][1])
def test_multi_add(self):
manager = TeamManager(RandomMock())
slack_client = MockSlackClient()
p1 = Player("p1", slack_client)
manager.add_player(p1)
manager.add_player(p1)
self.assertEqual(1, len(manager.players))
def test_multi_add(self):
manager = TeamManager(RandomMock())
slack_client = MockSlackClient()
p1 = Player("p1", slack_client)
manager.add_player(p1)
manager.add_player(p1)
self.assertEqual(1, len(manager.players))
def test_add_player(self):
slack_client = MockSlackClient()
manager = TeamManager(Chat(slack_client, "foo"))
manager.add_player(Player("p1", slack_client))
self.assertEqual(1, len(manager.players))
self.assertEqual("You have joined the game!", slack_client.api_calls[-1][1])
def setUp(self):
engine = create_engine('sqlite:///test_team_member.sqlite')
Base.metadata.create_all(engine)
Base.metadata.bind = engine
self.team_mgr = TeamManager('test_team_member.sqlite')
self.logPoint()
def finale_mode():
team_manager = TeamManager()
data_display = collections.deque(maxlen = dummy_server.RECENT)
incoming_data = Queue()
outgoing_data = Queue()
# Create server
server = Server()
# Processes
p_registration = Process(target=comms.registration_process, args=(server, incoming_data))
p_in = Process(target=comms.incoming_data_process, args=(server, incoming_data))
p_out = Process(target=comms.outgoing_data_process, args=(server, outgoing_data))
p_registration.start()
p_in.start()
p_out.start()
try:
if dummy_server.run(team_manager, data_display, incoming_data, outgoing_data, KEYBOARD):
points = ImageRandomiser(IMAGE_NAME, IMAGE_SIZE, IMAGE_SIZE, PIXEL_SIZE, CAMERA)
status = StatusDisplay(925, -25, CAMERA)
finale.run(team_manager, incoming_data, outgoing_data, points, status, DISPLAY, KEYBOARD)
except Exception as e:
LOGGER.info(str(e))
KEYBOARD.close()
DISPLAY.stop()
p_registration.terminate()
p_in.terminate()
p_out.terminate()
def __init__(self, db='orders.db'):
self.pm = PeopleManager()
self.tm = TeamManager()
self.cm = CoffeeManager()
self.db = sqlite3.connect(db)
self.db.execute('create table if not exists orders (name text, document text, unique (name))')
self.orders = self.retrieve()
def test_pick_teams_odd(self):
slack_client = MockSlackClient()
manager = TeamManager(Chat(slack_client, 'foo'), RandomMock())
manager.add_player(Player("p1", slack_client))
manager.add_player(Player("p2", slack_client))
manager.add_player(Player("p3", slack_client))
manager.add_player(Player("p4", slack_client))
manager.add_player(Player("p5", slack_client))
manager.pick_teams()
self.assertEqual(3, len(manager.blue_team))
self.assertEqual(2, len(manager.red_team))
self.assertEqual("p3", manager.blue_team[0].slack_id)
self.assertEqual("p4", manager.blue_team[1].slack_id)
self.assertEqual("p5", manager.blue_team[2].slack_id)
self.assertEqual("p1", manager.red_team[0].slack_id)
self.assertEqual("p2", manager.red_team[1].slack_id)
def test_pick_teams_odd(self):
slack_client = MockSlackClient()
manager = TeamManager(Chat(slack_client, "foo"), RandomMock())
manager.add_player(Player("p1", slack_client))
manager.add_player(Player("p2", slack_client))
manager.add_player(Player("p3", slack_client))
manager.add_player(Player("p4", slack_client))
manager.add_player(Player("p5", slack_client))
manager.pick_teams()
self.assertEqual(3, len(manager.blue_team))
self.assertEqual(2, len(manager.red_team))
self.assertEqual("p3", manager.blue_team[0].slack_id)
self.assertEqual("p4", manager.blue_team[1].slack_id)
self.assertEqual("p5", manager.blue_team[2].slack_id)
self.assertEqual("p1", manager.red_team[0].slack_id)
self.assertEqual("p2", manager.red_team[1].slack_id)
def main():
# set up our data
# generate some players, random(a couple hundred)
fighters = []
for i in range(100):
fighters.append(generate_fighter())
# set up 5 teams
teams = [
Team('Avengers'),
Team('Annihilators'),
Team('Black Panthers'),
Team('Brute Force'),
Team('Chaos'),
Team('Full Atack')
]
for team in teams:
for fighter_num in range(5):
# 5 fighters given from start at random
selected_fighter = random.choice(fighters)
team.fighters.append(selected_fighter)
fighters.remove(selected_fighter)
# create random fighters, create random managers(the player is one of those managers)
first_league = League('Battle Zone', teams, fighters)
first_league.set_teams(teams)
# create the manager(player)
manager = TeamManager(random.choice(teams), first_league)
"""
play 10 rounds between all our teams
"""
print('Tournament begins.')
for i in range(10):
manager.manage()
first_league.play_round()
print('Tournament ends.')
def __init__(self,
slack_client,
random_func=None,
chat=None,
channel=None):
self.chat = chat
self.channel = channel
self.team_manager = TeamManager(self.chat, random_func=random_func)
self.slack_client = slack_client
self.handler = PendingStartHandler(self)
self.board = Board(self.chat, random_func=random_func)
self.clue_input_handler = None
self.rand_func = random_func
self.clue_number = None
self.previous_handler = None
if not self.rand_func:
self.random_func = random
def test_get_spymasters(self):
slack_client = MockSlackClient()
manager = TeamManager(Chat(slack_client, "foo"), RandomMock())
p1 = Player("p1", slack_client)
p3 = Player("p3", slack_client)
manager.add_player(p1)
manager.add_player(Player("p2", slack_client))
manager.add_player(p3)
manager.add_player(Player("p4", slack_client))
manager.add_player(Player("p5", slack_client))
manager.pick_teams()
self.assertEqual(p1, manager.get_red_spymaster())
self.assertEqual(p3, manager.get_blue_spymaster())
def test_get_spymasters(self):
slack_client = MockSlackClient()
manager = TeamManager(Chat(slack_client, 'foo'), RandomMock())
p1 = Player("p1", slack_client)
p3 = Player("p3", slack_client)
manager.add_player(p1)
manager.add_player(Player("p2", slack_client))
manager.add_player(p3)
manager.add_player(Player("p4", slack_client))
manager.add_player(Player("p5", slack_client))
manager.pick_teams()
self.assertEqual(p1, manager.get_red_spymaster())
self.assertEqual(p3, manager.get_blue_spymaster())
def test_display_teams(self):
slack_client = MockSlackClient()
manager = TeamManager(Chat(slack_client, 'foo'), RandomMock())
manager.add_player(Player("p1", slack_client))
manager.add_player(Player("p2", slack_client))
manager.add_player(Player("p3", slack_client))
manager.add_player(Player("p4", slack_client))
manager.add_player(Player("p5", slack_client))
manager.pick_teams()
manager.display_teams()
red_team = "*Red Spymaster:*\np1\n\n*Red Field Operatives:\n*p2\n"
blue_team = "*Blue Spymaster:*\np3\n\n*Red Field Operatives:\n*p4\np5\n"
self.assertEqual(red_team, slack_client.api_calls[-1][1])
self.assertEqual(blue_team, slack_client.api_calls[-4][1])
class TestTeamManager(TestCase):
def setUp(self):
engine = create_engine('sqlite:///test_team_member.sqlite')
Base.metadata.create_all(engine)
Base.metadata.bind = engine
self.team_mgr = TeamManager('test_team_member.sqlite')
self.logPoint()
def tearDown(self):
os.remove('test_team_member.sqlite')
self.logPoint()
def logPoint(self):
"""utility function used for module functions and class methods"""
currentTest = self.id().split('.')[-1]
callingFunction = inspect.stack()[1][3]
print('in %s - %s()' % (currentTest, callingFunction))
def test_add(self):
"""Test if it's adding correctly and test if it raises a error in case it's provided the wrong type"""
team1 = Player("Bo", "Horvat", "12/02/2000", "C", 6.0, 215, 53, "L",
"player")
team2 = Staff("Jim", "Benning", "1/2/1945", "General Manager",
"01/07/2015", "Boston Bruins", "staff")
self.team_mgr.add(team1)
self.team_mgr.add(team2)
team_list = self.team_mgr.get_all()
print(team_list)
self.assertEqual(len(team_list), 2)
def test_add_invalid(self):
"""test invalid inputs in add team member"""
self.assertRaisesRegex(ValueError, 'Invalid Team Member Object',
self.team_mgr.add, None)
self.assertRaisesRegex(ValueError, 'Invalid Team Member Object',
self.team_mgr.add, [])
def test_update(self):
"""test update team member"""
team1 = Player("Bo", "Horvat", "12/02/2000", "C", 6.0, 215, 53, "L",
"player")
team1_id = self.team_mgr.add(team1)
datetime_format = datetime.datetime.strptime("12/02/2000", "%d/%m/%Y")
retrieve_updated_team = self.team_mgr.get(team1_id)
self.assertEqual(retrieve_updated_team.first_name, "Bo")
self.assertEqual(retrieve_updated_team.last_name, "Horvat")
self.assertEqual(retrieve_updated_team.date_of_birth, datetime_format)
self.assertEqual(retrieve_updated_team.position, "C")
self.assertEqual(retrieve_updated_team.height, 6.0)
self.assertEqual(retrieve_updated_team.weight, 215)
self.assertEqual(retrieve_updated_team.player_number, 53)
self.assertEqual(retrieve_updated_team.shoot, "L")
self.assertEqual(retrieve_updated_team.type, "player")
datetime_format = datetime.datetime.strptime("12/02/2000", "%d/%m/%Y")
retrieve_updated_team.first_name = "Bo"
retrieve_updated_team.last_name = "Horvat"
retrieve_updated_team.date_of_birth = datetime_format
retrieve_updated_team.position = "C/LW"
retrieve_updated_team.height = 6.1
retrieve_updated_team.weight = 220
retrieve_updated_team.player_number = 53
retrieve_updated_team.shoot = "L"
retrieve_updated_team.type = "player"
self.team_mgr.update(retrieve_updated_team)
retrieve_updated_team = self.team_mgr.get(team1_id)
self.assertEqual(retrieve_updated_team.first_name, "Bo")
self.assertEqual(retrieve_updated_team.last_name, "Horvat")
self.assertEqual(retrieve_updated_team.date_of_birth, datetime_format)
self.assertEqual(retrieve_updated_team.position, "C/LW")
self.assertEqual(retrieve_updated_team.height, 6.1)
self.assertEqual(retrieve_updated_team.weight, 220)
self.assertEqual(retrieve_updated_team.player_number, 53)
self.assertEqual(retrieve_updated_team.shoot, "L")
self.assertEqual(retrieve_updated_team.type, "player")
def test_update_invalid(self):
"""test invalid input for update_student"""
self.assertRaisesRegex(ValueError, "Invalid Team Member Object",
self.team_mgr.update, None)
self.assertRaisesRegex(ValueError, "Invalid Team Member Object",
self.team_mgr.update, [])
def test_delete(self):
"""test delete team member"""
team1 = Player("Bo", "Horvat", "12/02/2000", "C", 6.0, 215, 53, "L",
"player")
team1_id = self.team_mgr.add(team1)
retrieved_team = self.team_mgr.get(team1_id)
self.assertIsNotNone(retrieved_team)
self.team_mgr.delete(team1_id)
retrieved_team = self.team_mgr.get(team1_id)
self.assertIsNone(retrieved_team)
def test_delete_invalid(self):
"""test invalid input for update_student"""
self.assertRaisesRegex(ValueError, "Invalid Team Member ID",
self.team_mgr.delete, None)
self.assertRaisesRegex(ValueError, "Invalid Team Member ID",
self.team_mgr.delete, [])
def test_get(self):
"""test get team member"""
team1 = Player("Bo", "Horvat", "12/02/2000", "C", 6.0, 215, 53, "L",
"player")
team2 = Staff("Jim", "Benning", "1/2/1945", "General Manager",
"01/07/2015", "Boston Bruins", "staff")
team1_id = self.team_mgr.add(team1)
team2_id = self.team_mgr.add(team2)
datetime_format1 = datetime.datetime.strptime("12/02/2000", "%d/%m/%Y")
retrieve_team1 = self.team_mgr.get(team1_id)
self.assertIsNotNone(retrieve_team1)
self.assertEqual(retrieve_team1.first_name, "Bo")
self.assertEqual(retrieve_team1.last_name, "Horvat")
self.assertEqual(retrieve_team1.date_of_birth, datetime_format1)
self.assertEqual(retrieve_team1.position, "C")
self.assertEqual(retrieve_team1.height, 6.0)
self.assertEqual(retrieve_team1.weight, 215)
self.assertEqual(retrieve_team1.player_number, 53)
self.assertEqual(retrieve_team1.shoot, "L")
self.assertEqual(retrieve_team1.type, "player")
datetime_format2 = datetime.datetime.strptime("1/2/1945", "%d/%m/%Y")
datetime_format3 = datetime.datetime.strptime("01/07/2015", "%d/%m/%Y")
retrieve_team2 = self.team_mgr.get(team2_id)
self.assertIsNotNone(retrieve_team2)
self.assertEqual(retrieve_team2.first_name, "Jim")
self.assertEqual(retrieve_team2.last_name, "Benning")
self.assertEqual(retrieve_team2.date_of_birth, datetime_format2)
self.assertEqual(retrieve_team2.position, "General Manager")
self.assertEqual(retrieve_team2.hire_date, datetime_format3)
self.assertEqual(retrieve_team2.previous_team, "Boston Bruins")
self.assertEqual(retrieve_team2.type, "staff")
def test_get_invalid(self):
""""test invalid input in get_student"""
self.assertRaisesRegex(ValueError, "Invalid Team Member ID",
self.team_mgr.get, None)
self.assertRaisesRegex(ValueError, "Invalid Team Member ID",
self.team_mgr.get, [])
def test_get_all_by_type(self):
"""test get all by type"""
team1 = Player("Bo", "Horvat", "12/02/2000", "C", 6.0, 215, 53, "L",
"player")
team1_id = self.team_mgr.add(team1)
team_all = self.team_mgr.get_all_by_type("player")
player1 = team_all[0].TYPE
self.assertEqual(player1, "player")
def test_get_all_by_type_invalid(self):
"""test invalid input for get_all_by_type"""
self.assertRaisesRegex(ValueError, "Invalid Type for Team Member",
self.team_mgr.get_all_by_type, None)
self.assertRaisesRegex(ValueError, "Invalid Type for Team Member",
self.team_mgr.get_all_by_type, [])
def test_get_all(self):
"""test get all"""
team_all = self.team_mgr.get_all()
self.assertEqual(len(team_all), 0)
team1 = Player("Bo", "Horvat", "12/02/2000", "C", 6.0, 215, 53, "L",
"player")
team2 = Staff("Jim", "Benning", "1/2/1945", "General Manager",
"01/07/2015", "Boston Bruins", "staff")
team1_id = self.team_mgr.add(team1)
team2_id = self.team_mgr.add(team2)
team_all = self.team_mgr.get_all()
self.assertEqual(len(team_all), 2)
def test_display_teams(self):
slack_client = MockSlackClient()
manager = TeamManager(Chat(slack_client, "foo"), RandomMock())
manager.add_player(Player("p1", slack_client))
manager.add_player(Player("p2", slack_client))
manager.add_player(Player("p3", slack_client))
manager.add_player(Player("p4", slack_client))
manager.add_player(Player("p5", slack_client))
manager.pick_teams()
manager.display_teams()
red_team = "*Red Spymaster:*\np1\n\n*Red Field Operatives:\n*p2\n"
blue_team = "*Blue Spymaster:*\np3\n\n*Red Field Operatives:\n*p4\np5\n"
self.assertEqual(red_team, slack_client.api_calls[-1][1])
self.assertEqual(blue_team, slack_client.api_calls[-4][1])
class OrderManager(object):
'''Manages orders'''
def __init__(self, db='orders.db'):
self.pm = PeopleManager()
self.tm = TeamManager()
self.cm = CoffeeManager()
self.db = sqlite3.connect(db)
self.db.execute('create table if not exists orders (name text, document text, unique (name))')
self.orders = self.retrieve()
def retrieve(self):
rows = self.db.execute('select * from orders')
return [self.make_from_row(row) for row in rows]
def add(self, name, team):
team = self.find_team(team)
o = Order()
o.name = name
o.team = team
self.orders.append(o)
def create_item(self, person, coffee, pounds, quantity, personal):
return Item(person, coffee, pounds, quantity, personal)
def add_item(self, order, person, coffee, lbs, qty, personal):
o = self.find(order)
p = self.pm.find(person)
c = self.cm.find(coffee)
if len(o) != 1:
#print('Did not find a unique order match for "%s"' % order)
return False
o = o[0]
if len(p) != 1:
#print('Did not find a unique person match for "%s"' % person)
return False
p = p[0]
if len(c) != 1:
#print('Did not find a unique coffee match for "%s"' % coffee)
return False
# TODO remove the list/obj inconsistencies so stuff like this can go away
if isinstance(o.team, list): o.team = o.team[0]
if isinstance(p.team, list): p.team = p.team[0]
if o.team.name != p.team:
#print('%s is not on team %s, forcing personal order' % (p.name, o.team))
personal = True
item = self.create_item(p, c[0], lbs, qty, personal)
o.items.append(item)
return True
def remove_item(self, order, who, coffee):
o = self.find(order)[0]
who = self.pm.find(who)[0]
c = self.cm.find(coffee)[0]
allitems = [i for i in o.items]
eligible = [i for i in o.items if i.person.name == who.name and i.coffee.name == c.name]
#print('Found %s coffee to remove' % len(eligible))
for e in eligible:
o.items.remove(e)
def update_item(self, order, who, coffee, pounds, quantity):
o = self.find(order)[0]
who = self.pm.find(who)[0]
eligible = [i for i in o.items if i.person.name == who.name and i.coffee.name == coffee]
if len(eligible) > 1:
raise Exception('Too many matching items (%s) to update' % len(eligible))
c = eligible[0]
c.quantity = quantity
c.pounds = pounds
def find(self, search):
return [o for o in self.orders if search in o.name]
def find_team(self, teamname):
team = self.tm.find(teamname)
if len(team) != 1:
print('failed to find a unique team with search "%s"' % teamname)
return None
return team
def remove(self, name):
eligible = [o for o in self.orders if o.name == name]
for e in eligible:
self.orders.remove(e)
def commit(self):
self.db.execute('delete from orders')
for o in self.orders:
try:
self.db.execute('insert into orders values (?, ?)', (o.name, json.dumps(o, cls=OrderJSONEncoder)))
except sqlite3.IntegrityError:
print('failed to add order "%s" because an order with that name already exists' % o.name)
self.db.commit()
def print(self):
for o in self.orders:
print(o)
def clear(self):
self.db.execute('drop table orders')
self.db.commit()
def make_from_row(self, row):
name = row[0]
return self.deserialize(row[1])
def deserialize(self, doc):
doc = json.loads(doc)
o = Order()
o.name = doc['name']
o.date = datetime.datetime.strptime(doc['date'], '%Y-%m-%dT%H:%M:%S.%f')
if isinstance(doc['team'], list):
doc['team'] = doc['team'][0]
o.team = Team(doc['team']['name'], doc['team']['description'])
for i in doc['items']:
p = self.pm.find(i['person'])[0]
c = self.cm.find(i['coffee'])[0]
lbs = i['pounds']
qty = i['quantity']
item = Item(p, c, lbs, qty, i['personal'])
o.items.append(item)
return o
def teamtotal(self, order):
return sum([(i.quantity * i.coffee.prices[i.pounds]) for i in order.items if not i.personal])
def personaltotal(self, order):
return sum([(i.quantity * i.coffee.prices[i.pounds]) for i in order.items if i.personal])
def grandtotal(self, order):
return self.teamtotal(order) + self.personaltotal(order)
def individualtotal(self, order, who):
'''if on team: teamtotal / numonteam + personalorder, otherwise: personalorder'''
summo = 0
who = self.pm.find(who)[0]
if order.team.name == who.team:
num_on_team = len([p for p in self.pm.people if p.team == order.team.name])
summo = self.teamtotal(order) / float(num_on_team)
summo += sum([i.quantity*i.coffee.prices[i.pounds] for i in order.items if i.personal and i.person.name == who.name])
else:
summo = sum([i.quantity * i.coffee.prices[i.pounds] for i in order.items if i.personal and i.person.name == who.name])
return summo
def totals(self, order):
cur = locale.currency
s = []
o = self.find(order)[0]
s.append('''
Team Total......%s
Personal Total..%s
Grand Total.....%s
Individual Totals:''' % (cur(self.teamtotal(o)), cur(self.personaltotal(o)), cur(self.grandtotal(o))))
unique_people = set([i.person.name for i in o.items])
for p in unique_people:
s.append('\t%s: %s' % (p, locale.currency(self.individualtotal(o, p))))
return ''.join(s)
import variables as var
from pygame.math import Vector2
from map import *
from enum import Enum
import time
from worm import Worm
from team_manager import TeamManager
map = Map("Map.bmp", "background.bmp")
map.remove_circle(Vector2(1200, 500), 150)
pygame.font.init()
TeamManager()
font = pygame.font.SysFont("comicsansms", 48)
physic_objects_list = [Worm((100, 100)), Worm((1500, 1500), is_selected=True)]
teams = []
def cameraScrolling(frame_time: float):
if var.scroling_X_Inc and var.camera_vector.x + var.SCREEN_WIDTH < map.surface.get_width(
):
var.camera_vector.x += var.SCROLLING_SPEED * frame_time
if var.camera_vector.x + var.SCREEN_WIDTH > map.surface.get_width():
var.camera_vector.x = map.surface.get_width() - var.SCREEN_WIDTH
if var.scroling_X_Dec and var.camera_vector.x > 0:
var.camera_vector.x -= var.SCROLLING_SPEED * frame_time
if var.camera_vector.x < 0:
var.camera_vector.x = 0
if var.scroling_Y_Inc and var.camera_vector.y + var.SCREEN_HEIGHT < map.surface.get_height(
):
var.camera_vector.y += var.SCROLLING_SPEED * frame_time
from flask import Flask, request
from player import Player
from team_manager import TeamManager
from staff import Staff
import json
app = Flask(__name__)
CANUCKS_DB = 'canucks.sqlite'
canucks = TeamManager(CANUCKS_DB)
@app.route('/team_manager/employee', methods=['POST'])
def add_member():
"""adds employee object based on type and assigns object an ID number"""
content = request.json
try:
if content['type'] == 'staff':
staff = Staff(content['first_name'], content['last_name'],
content['date_of_birth'], content['position'],
content['hire_date'], content['previous_team'],
content['type'])
id = canucks.add(staff)
elif content['type'] == 'player':
player = Player(content['first_name'], content['last_name'],
content['date_of_birth'], content['position'],
float(content['height']), float(content['weight']),
int(content['player_number']), content['shoot'],
content['type'])
id = canucks.add(player)
