def setUp(self):
super().setUp()
self.mitch = AppUser(phone_number=self.inviter_number,
username='******',
timezone=US_TIMEZONES['b'])
self.db.session.add(self.mitch)
self.billy = AppUser(phone_number=self.secondary_number,
username='******',
timezone=US_TIMEZONES['b'])
self.db.session.add(self.billy)
self.team = Team(founder=self.mitch, name='The Cherrys')
self.db.session.add(self.team)
self.mitch_member = TeamMember(user=self.mitch,
team=self.team,
inviter=self.mitch,
status=Statuses.ACTIVE)
self.db.session.add(self.mitch_member)
self.billy_member = TeamMember(user=self.billy,
team=self.team,
inviter=self.mitch,
status=Statuses.PENDING)
self.db.session.add(self.billy_member)
self.db.session.commit()
self.mitch = self.mitch.to_dict()
self.billy = self.billy.to_dict()
self.team = self.team.to_dict()
def seed_teams():
user = User.query.filter(User.username == "Demo").first()
data = [Team(teamName="Gold"), Team(teamName="Green")]
for team in data:
user.teams.append(team)
db.session.add(team)
db.session.commit()
def team_match_storage(self, data):
for d in data:
group = Group.query.filter_by(name=d["group_name"]).first()
if group is None:
group = Group(name=d["group_name"])
db.session.add(group)
v1 = Team.query.filter_by(name=d["v1"]).first()
if v1 is None:
v1 = Team(name=d["v1"], group=group)
v1_pinyin = TeamPinYin(name=pinyin.get(d["v1"],
format="strip"),
team=v1)
db.session.add(v1)
db.session.add(v1_pinyin)
v2 = Team.query.filter_by(name=d["v2"]).first()
if v2 is None:
v2 = Team(name=d["v2"], group=group)
v2_pinyin = TeamPinYin(name=pinyin.get(d["v2"],
format="strip"),
team=v2)
db.session.add(v2)
db.session.add(v2_pinyin)
db.session.commit()
duel = Duel(team_er=v1,
team_ed=v2,
t1_score=d["vs"][0],
t2_score=d["vs"][2],
datetime=d["datetime"],
area=d["area"],
group_cls=d["group_cls"])
db.session.add(duel)
db.session.commit()
print("保存%s小组赛成功..." % d["group_name"])
def seed_teams():
team1 = Team(name="Water-Team", user_id="1")
team2 = Team(name="Fire-Team", user_id="1")
db.session.add(team1)
db.session.add(team2)
db.session.commit()
def setUp(self):
super().setUp()
# add a user
self.mitch = AppUser(phone_number=self.inviter_number,
username='******',
timezone=US_TIMEZONES['b'])
self.db.session.add(self.mitch)
# self.db.session.add(self.blair)
# add a notif
self.notif = Notification(router=RouterNames.DID_YOU_DO_IT,
hour=21,
minute=0,
active=True,
user=self.mitch)
self.db.session.add(self.notif)
# add exchange
self.exchange = Exchange(router=RouterNames.DID_YOU_DO_IT,
outbound='Did you do it?',
user=self.mitch,
created=dt.datetime.now() -
dt.timedelta(days=10))
self.db.session.add(self.exchange)
# add point
self.point = Point(value=10, user=self.mitch)
# add task
self.task = Task(description='Win today',
due_date=dt.datetime.now(),
active=True,
exchange=self.exchange,
user=self.mitch)
self.db.session.add(self.task)
self.inteam = Team(id=TEST_TEAM_ID, founder=self.mitch, name='inteam')
self.db.session.add(self.inteam)
self.pendingteam = Team(founder=self.mitch, name='pendingteam')
self.db.session.add(self.pendingteam)
self.mitch_member = TeamMember(user=self.mitch,
team=self.inteam,
inviter=self.mitch,
status=Statuses.ACTIVE)
self.db.session.add(self.mitch_member)
self.mitch_member2 = TeamMember(user=self.mitch,
team=self.pendingteam,
inviter=self.mitch,
status=Statuses.PENDING)
self.db.session.add(self.mitch_member2)
def seed_teams():
team1 = Team(name='Valor')
team2 = Team(name='Mystic')
team3 = Team(name='Instinct')
db.session.add(team1)
db.session.add(team2)
db.session.add(team3)
db.session.commit()
def test_team(self):
team1 = Team(name='Yankees', city='New York', abbreviation='NYY')
team2 = Team(name='Cubs', city='Chicago', abbreviation='CHC')
db.session.add(team1)
db.session.add(team2)
db.session.commit()
self.assertEqual(team1.name, 'Yankees')
self.assertEqual(team1.city, 'New York')
self.assertEqual(team1.abbreviation, 'NYY')
self.assertEqual(team2.name, 'Cubs')
self.assertEqual(team2.city, 'Chicago')
self.assertEqual(team2.abbreviation, 'CHC')
def deploy():
"""Deployment tasks"""
#migrate database to latest revision
upgrade()
#create user roles
Role.insert_roles()
#insert matches from the data file
Team.insert_teams()
#insert modules
PredictionModule.insert_modules()
#insert matches from the data file
Match.update_all_matches()
def teams_post(id):
form = TeamForm()
user = User.query.get(id)
form['csrf_token'].data = request.cookies['csrf_token']
if form.validate_on_submit():
team = Team(
teamName=form.data['teamName'],
)
team.users.append(user)
db.session.add(team)
db.session.commit()
return team.to_dict()
return "Oops, something went wrong!"
def setUpTestData(cls):
admin = Group(name='Admin')
admin.save()
coach = Group(name='Coach')
coach.save()
player = Group(name='Player')
player.save()
admin_user = User.objects.create_user(username='******', email='*****@*****.**', is_staff=True,
password='******')
admin.user_set.add(admin_user)
cls.colombo_fc_user1 = User.objects.create_user(username='******', email='*****@*****.**',
password='******')
player.user_set.add(cls.colombo_fc_user1)
cls.colombo_fc_user2 = User.objects.create_user(username='******', email='*****@*****.**',
password='******')
player.user_set.add(cls.colombo_fc_user2)
cls.navy_sc_user1 = User.objects.create_user(username='******', email='*****@*****.**',
password='******')
player.user_set.add(cls.navy_sc_user1)
cls.navy_sc_user2 = User.objects.create_user(username='******', email='*****@*****.**',
password='******')
player.user_set.add(cls.navy_sc_user2)
cls.first_round = GameRound(name='First Round')
cls.first_round.save()
quarter_final = GameRound(name='Quarter Final')
quarter_final.save()
semi_final = GameRound(name='Semi Final')
semi_final.save()
final = GameRound(name='Final')
final.save()
cls.colombo_fc = Team(name='Colombo FC')
cls.colombo_fc.save()
cls.navy_sc = Team(name='Navy SC')
cls.navy_sc.save()
cls.game = Game(host=cls.navy_sc, guest=cls.colombo_fc, winner=cls.navy_sc, round=cls.first_round
, date='2020-12-23')
cls.game.save()
cls.navy_sc_player = Player(user=cls.navy_sc_user1, team=cls.navy_sc, height=179)
cls.navy_sc_player.save()
cls.player_stat = PlayerStat(player=cls.navy_sc_player, game=cls.game, score=1)
cls.player_stat.save()
cls.team_stat = TeamStat(team=cls.navy_sc, game=cls.game, score=1)
cls.team_stat.save()
cls.site_stat = SiteStat(user=cls.navy_sc_user1, login_time='2021-02-15T04:25:37+05:30',
logout_time='2021-02-15T16:59:16+05:30')
cls.site_stat.save()
def add_team():
form = TeamForm(request.form)
if form.validate_on_submit():
team = Team()
team.fio = form.fio.data
file = request.files['avatar']
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
team.avatar = filename
db.session.add(team)
db.session.commit()
return redirect('/')
return render_template('add_team.html', form=form)
def add_team(request):
if not request.user.is_staff:
raise Http404
if request.POST.get('teamName'):
teamName = request.POST.get('teamName')
teamStructure = request.POST.get('teamStructure')
teamGame = Game.objects.get(pk=request.POST.get('teamGame'))
team = Team(name=teamName, structure=teamStructure, game=teamGame)
team.save()
else:
print("error: Team was not created")
return redirect('/admin')
def team(request):
"""
"""
if request.method == 'POST':
team_name = request.POST.get('teamname', False)
if team_name:
new_team = Team()
new_team.team_name = team_name
new_team.save()
return HttpResponseRedirect(reverse('players', args=(new_team.id,)))
else:
return render(request, 'app/add_team.html')
else:
return render(request, 'app/add_team.html')
def team(client, app):
with app.app_context():
db.session.add(Team(id=1, name='Test Team', status='completed'))
db.session.commit()
yield db.session.query(Team).all()
def create_team():
user = users.get(current_user.id)
created_teams = team_service.get_teams_for_user(user.id, 'created')
completed_teams = team_service.get_teams_for_user(user.id)
if len(completed_teams) == 0:
if len(created_teams) == 0:
team = team_service.save(
Team(name='',
status='created',
team_members=[
TeamMember(user_id=user.id, is_team_lead=True)
]))
audit_service.log_audit_event(audit_type=audit_types.create_team,
data={},
db_object=team,
user=current_user.email_address)
publish_tasks.team.delay(publish_tasks.compress_team(team),
'created')
return get_team(team.id)
created_team = created_teams.pop()
return get_team(created_team.id)
else:
team = completed_teams[0]
raise TeamError(
'You can only be in one team. You\'re already a member of {}.'.
format(team.name))
def join_team(account, teamID=None, teamPass=None, team=None):
# Look up the team if we didn't bring one
if team is None:
team = Team.objects(teamID=teamID, teamPass=teamPass).first()
# We didn't bring a team nor did we find one
if team is None:
error = "Team with those credentials not found."
# We have our team, let's try joining
if team:
if len(team.members) < 3:
team.members.append(account)
account.team = team
validate_division(team)
team.save()
account.save()
return True
else:
flash("Team already has 3 members", 'danger')
return False
flash("Error finding team", 'danger')
return False
def test_can_create_table_entry_from_api_response():
table_entry = TableEntry.parse_obj({
"position": 2,
"team": {
"id": 65,
"name": "Manchester City FC",
"crestUrl": "https://upload.wikimedia.org/wikipedia/en/e/eb/Manchester_City_FC_badge.svg"
},
"playedGames": 31,
"won": 20,
"draw": 3,
"lost": 8,
"points": 63,
"goalsFor": 77,
"goalsAgainst": 33,
"goalDifference": 44
})
assert table_entry.position == 2
assert table_entry.team == Team(id=65, name='Manchester City FC')
assert table_entry.played_games == 31
assert table_entry.won == 20
assert table_entry.draw == 3
assert table_entry.lost == 8
assert table_entry.goals_for == 77
assert table_entry.goals_against == 33
assert table_entry.goal_difference == 44
def _create_team(request):
team = Team()
form = TeamForm(request.form)
form.populate_obj(team)
db.session.add(team)
db.session.commit()
return team
def changeActivitiesProcess():
teams = current_user.entry.teams.count()
activities = form_input_array(request.form, "activity")
# TODO: sort cascades properly (can't test on SQLite)
for team in current_user.entry.teams:
team.clearScores()
current_user.entry.teams.delete()
current_user.entry.activities.delete()
db.session.commit()
if len(activities) != 4:
flash("Please select four activities", "warning")
return redirect(url_for("scoring.changeActivities"))
for activity in activities:
obj = Activity.query.get(activity[1])
if obj:
current_user.entry.activities.append(EntryActivities(activity=obj))
else:
flash("Please select a valid activity", "warning")
return redirect(url_for("scoring.changeActivities"))
for team in range(1, teams + 1):
current_user.entry.teams.append(Team())
db.session.commit()
return redirect(url_for("scoring.index"))
def create_team(game_id):
form = CreateTeamForm()
existing_player_team = PlayerTeam.query.join(Team).filter(
PlayerTeam.player_id == g.current_player.id, Team.game_id == game_id).one_or_none()
if existing_player_team:
form.autojoin_team.data = False
form.autojoin_team.render_kw = {'disabled':''}
if form.validate_on_submit(): # make sure game is open, stuff like that, user is logged in, user isnt already in game
new_team = Team(name=form.name.data, game_id=game_id)
db.session.add(new_team)
db.session.flush()
if form.autojoin_team.data:
player_team = PlayerTeam(player_id=g.current_player.id, team_id=new_team.id)
db.session.add(player_team)
db.session.commit()
return True, redirect(url_for('.view_game', game_id=game_id))
return False, render_template(
'salad_bowl/actions/create_team.html',
form=form,
action_url=url_for('salad_bowl.create_team', game_id=game_id))
def flumride_set_has_payed(id):
team = Team.get(id)
team.has_payed = True
db.session.commit()
resp = jsonify(has_payed=True)
resp.status_code = 200
return resp
def manageteam(id):
project = Project.query.filter_by(id=id).first_or_404()
form = TeamForm()
team = Team.query.filter_by(project_id=int(id)).order_by(
Team.role.asc()).all()
if form.validate_on_submit():
member = Team(role=form.role.data,
firstname=form.fName.data,
lastname=form.lName.data,
email=form.email.data,
project_id=project.id)
exists = Team.query.filter_by(project_id=int(id),
role=form.role.data).first()
if not exists:
db.session.add(member)
db.session.commit()
flash('Team Member {} {} added'.format(form.fName.data,
form.lName.data))
else:
db.session.commit()
flash('Team Member {} {} updated'.format(form.fName.data,
form.lName.data))
return redirect(url_for('manageteam', id=project.id))
return render_template('manageteam.html',
title='Manage Team Members',
team=team,
form=form,
project=project)
def join_to_event(current_user, event_id):
team_id = request.args.get('teamId', None, type=int)
try:
int(event_id)
except ValueError:
return response('failed', 'Please provide a valid Event Id', 400)
user = User.get_by_id(current_user.id)
event = Event.get_by_id(event_id)
if not event:
abort(404)
if event == EventStatus.canceled:
return response('failed', 'Event was canceled', 400)
if event == EventStatus.ended:
return response('failed', 'Event was ended', 400)
if team_id:
team = Team.get_by_id(team_id)
if not team:
return response('failed', 'Team cannot be found', 404)
if not team in event.teams:
return response(
'failed', 'The Event with Id ' + event_id +
' doesn\'t have Team with Id ' + team_id, 404)
elif event.type is EventType.training:
team = event.training.team
else:
return response('failed',
'Event with given Id requires teamId to join', 404)
#check requirements to join
if not (event.participants_age_from <= user.age <=
event.participants_age_to):
return response(
'failed', 'User\'s age does\'t meet the requirements of the event',
400)
if user in team.participants:
return response('failed', 'User already joined to the team', 400)
if team.is_full:
return response('failed', 'Team is full', 400)
# remove user from other team in event
for t in event.teams:
if user in t.participants:
t.participants.remove(user)
# add user to team
team.participants.append(user)
team.update()
return response_for_created_event(event.json(current_user), 201)
def teams(app):
with app.app_context():
db.session.add(
Team(id=1,
name='Marketplace',
email_address='*****@*****.**',
status='completed'))
db.session.add(
Team(id=2,
name='Cloud',
email_address='*****@*****.**',
status='completed'))
db.session.commit()
yield db.session.query(Team).all()
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm()
if form.validate_on_submit():
team = Team(username=form.username.data,
team_name=form.team_name.data,
trainer=form.trainer.data,
trainer_email=form.trainer_email.data,
team_size=form.team_size.data,
athlete_userids=form.athlete_userids.data)
team.set_password(form.password.data)
db.session.add(team)
db.session.commit()
flash('Congratulations, your team is now registered!')
return redirect(url_for('login'))
return render_template('register.html', title='Register', form=form)
def test_team_fails_validation_with_bad_email_address(
self, users, user, email_address):
team = Team(name='Marketplace', email_address=email_address)
errors = TeamValidator(team, user).validate_basics()
assert len(errors) >= 1
assert any(error['id'] == 'T002' for error in errors)
def test_team_passes_validation_with_name_and_email(self, users, user):
team = Team(email_address='*****@*****.**',
name='Marketplace')
errors = TeamValidator(team, user,
['teamtest.gov.au']).validate_basics()
assert len(errors) == 0
def test_team_fails_validation_when_email_domain_is_different_to_user_domain(
self, users, user):
team = Team(name='Marketplace',
email_address='*****@*****.**')
errors = TeamValidator(team, user).validate_basics()
assert len(errors) == 1
assert any(error['id'] == 'T003' for error in errors)
def test_show_teams_api(self):
team = Team(name='cricket', logouri=IMAGE)
db.session.add(team)
db.session.commit()
url = 'http://localhost:5000/teams'
teams = self.app.get(url).data
teams = json.loads(teams)['teams']
self.assertEquals(len(teams), 1)
self.assertEquals(teams[0]['name'], 'cricket')
def test_add_high5s(self):
new_user = User(user_name='Jimmy',
name='Jimmy John',
email='*****@*****.**',
password='******')
app_db.session.add(new_user)
app_db.session.commit()
new_team = Team(name="Men's Running Club Test", admin="Jimmy")
team_members = []
team_members.append("John")
team_members.append("Tom")
list(set(team_members))
for team_member in team_members:
user1 = User.query.filter(User.user_name == team_member).one()
if user1:
new_team.members.append(user1)
app_db.session.add(new_team)
high5_1 = High5(
receiver='Tom',
giver='Jimmy',
message=
'Tom went in to extra office hours to get feedback on our project change idea',
time_posted=datetime.datetime.utcnow(),
level=5,
team=new_team)
high5_2 = High5(
receiver='John',
giver='Tom',
message=
'John went to the store to get supplies to make paper prototypes.',
time_posted=datetime.datetime.utcnow(),
level=4,
team=new_team)
app_db.session.add(high5_1)
app_db.session.add(high5_2)
app_db.session.commit()
high5s = High5.query.filter(
High5.team_name == "Men's Running Club Test").all()
self.assertEqual(len(high5s), 2)
john = User.query.filter(User.user_name == "John").one()
new_team.members.remove(john)
High5.query.filter(
High5.team_name == "Men's Running Club Test").filter(
High5.receiver == "John").delete()
app_db.session.commit()
high5s = High5.query.filter(
High5.team_name == "Men's Running Club Test").all()
self.assertEqual(len(high5s), 1)
app_db.session.delete(new_team)
app_db.session.delete(new_user)
app_db.session.commit()
team_exists = Team.query.filter(
Team.name == "Men's Running Club Test").all()
self.assertEqual(len(team_exists), 0)
high5s = High5.query.filter(
High5.team_name == "Men's Running Club Test").all()
self.assertEqual(len(high5s), 0)
def register_league(league):
form = LeagueRegistrationForm()
league = League.query.filter_by(id=int(league)).first()
teams = current_user.get_teams()
if teams is not None:
form.teams.choices = [(team.id, "{}".format(team.name))
for team in teams]
if request.method == 'POST':
if form.new_team.data:
# create a new team
team = Team.query.filter_by(name=form.new_team.data).first()
if team is not None and team.account_id == current_user.id:
flash(
'The team already exists, please select the team in the menu or create a team with another name!'
)
return redirect(url_for('register_league', league=league.id))
else:
team = Team(name=form.new_team.data, account=current_user)
db.session.add(team)
else:
team_id = form.teams.data
team = Team.query.filter_by(id=team_id).first()
if team.has_registered(league):
flash('The team has already registered the league!')
return redirect(url_for('index'))
elif league.registrable():
league_team = League_Team(
league_id=league.id,
team_id=team.id,
scheduling_requests=form.scheduling_requests.data)
league.team_num = league.team_num + 1
league_team.league = league
league_team.team = team
db.session.add(league_team)
db.session.commit()
send_confirmation_email(current_user, team, league)
flash('The member has successfully registered the event!')
return redirect(url_for('index'))
else:
flash(
'There registration is up to limit, contact us for further info!'
)
return redirect(url_for('index'))
return render_template('league_register.html', form=form)
def check_sched_loaded(Team, messages, err):
print("check_sched")
messages.append("Checking to see if schedule is loaded for " + Team.name)
if not Team.is_pst_sched_loaded():
messages.append("Schedule not loaded, getting it now")
count = get_games(Team, messages, err)
if count:
return count
else:
messages.append("Schedule is already loaded")
def populate():
Position.insert_positions()
with app.open_resource('./testing/data/teams.json') as teamdata:
team_dict = json.load(teamdata)['teams']
team_models = []
for t in team_dict:
Team.add_team(name=t['name'],
conference=t['conference'],
gm=t['gm'],
season=2014)
with app.open_resource('./testing/data/players.json') as playerdata:
player_dict = json.load(playerdata)['players']
for p in player_dict:
Player.add_player(name=p['name'],
positions=p['positions'],
team=p['team'])
Player_Season
populate_games()
populate_stats()
def setUp(self):
self.app = create_app('testing')
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
#create user roles
Role.insert_roles()
#insert matches from the data file
Team.insert_teams()
#insert modules
PredictionModule.insert_modules()
#insert matches from the data file
Match.update_all_matches()
self.u1 = User(email='*****@*****.**', password='******')
self.u1.confirmed = True
db.session.add(self.u1)
db.session.commit()
matches = Match.query.all()
# couple of non-played matches
self.match1 = Match.query.all()[len(matches) - 2]
self.match2 = Match.query.all()[len(matches) - 1]
# some played matches
self.match3 = Match.query.all()[12]
self.match4 = Match.query.all()[16]
# draw match
self.match5 = Match.query.all()[14]
self.u1.save_match(self.match1)
self.u1.save_match(self.match2)
self.u1.save_match(self.match3)
self.u1.save_match(self.match4)
self.u1.save_match(self.match5)
db.session.add(self.u1)
db.session.commit()
def get_team_key(self, team, campus, semester, team_old=None):
"""
Get (or create) a team and return its model instance
:param team: The team data
:param campus: The campus data
:return: The team model
:rtype: app.models.Team
"""
logging.debug("Getting information about team %s in campus %s and semesters %s", team.code, campus.name,
semester.name)
key = self.generate_team_key(team, campus, semester)
model_key = ndb.Key(Team, key)
modified = False
team_model = None
if team_old is None:
logging.debug("Creating team '%s'", team.code)
team_model = Team(
key=ndb.Key(Team, key),
code=team.code,
vacancies_offered=team.vacancies_offered,
vacancies_filled=team.vacancies_filled,
teachers=[],
schedules=[]
)
team_old = json.loads(json.dumps(team_model, cls=JSONEncoder))
modified = True
if str(team_old["vacancies_offered"]) != str(team.vacancies_offered):
logging.warn("The vacancies offered of the team '%s' changed", team.code)
logging.warn("%s != %s", str(team.vacancies_offered), str(team_old["vacancies_offered"]))
modified = True
if str(team_old["vacancies_filled"]) != str(team.vacancies_filled):
logging.warn("The vacancies filled of the team '%s' changed", team.code)
logging.warn("%s != %s", str(team.vacancies_filled), str(team_old["vacancies_filled"]))
modified = True
if sorted(map(self.generate_teacher_key, team.teachers)) != sorted(map(lambda teacher: str(teacher["id"]), team_old["teachers"])):
logging.warn("The teachers list of the team '%s' changed", team.code)
logging.warn("%s != %s", str(sorted(map(self.generate_teacher_key, team.teachers))), str(sorted(map(lambda teacher: str(teacher["id"]), team_old["teachers"]))))
modified = True
if sorted(map(self.generate_schedule_key, team.schedules)) != sorted(map(lambda schedule: str(schedule["id"]), team_old["schedules"])):
logging.warn("The schedules list of the team '%s' changed", team.code)
logging.warn("%s != %s", str(sorted(map(self.generate_schedule_key, team.schedules))), str(sorted(map(lambda schedule: str(schedule["id"]), team_old["schedules"]))))
modified = True
if modified:
logging.warning("Saving to NDB (team '%s')", team.code)
if team_model is None:
team_model = teams_module.get_team(key)
if team_model is None:
logging.warning("For some reason the team was not found in cache and its not new...Loading/recreating")
team_model = yield Team.get_or_insert_async(
key,
code=team.code,
vacancies_offered=team.vacancies_offered,
vacancies_filled=team.vacancies_filled,
teachers=[],
schedules=[],
context_options=context_options
)
team_model.vacancies_offered = team.vacancies_offered
team_model.vacancies_filled = team.vacancies_filled
if sorted(map(self.generate_teacher_key, team.teachers)) != sorted(map(lambda teacher: str(teacher["id"]), team_old["teachers"])):
team_model.teachers = yield map(self.get_teacher_key, team.teachers)
if sorted(map(self.generate_schedule_key, team.schedules)) != sorted(map(lambda schedule: str(schedule["id"]), team_old["schedules"])):
team_model.schedules = yield map(self.get_schedule_key, team.schedules)
yield team_model.put_async(options=context_options)
teams_module.get_team(key, overwrite=True, update_with=team_model)
raise ndb.Return({
"model": team_model,
"modified": modified,
"key": model_key
})
import pandas as pd
from app import db
import sys
from app.models import Team, Ratings
log = logging.getLogger(__name__)
db.create_all()
reload(sys)
sys.setdefaultencoding('utf8')
try:
teams_data = pd.read_csv("static/test_teams.csv")
for index, row in teams_data.iterrows():
team = Team()
team.team_id = int(row["team_id"])
team.team_name = row["team_name"].decode('utf-8')
team.series_id = int(row["series_id"])
team.series_name = row["series_name"]
db.session.add(team)
db.session.commit()
except Exception as e:
log.error("Update ViewMenu error: {0}".format(str(e)))
db.session.rollback()
try:
teams_data = pd.read_csv("static/test_ratings.csv")
for index, row in teams_data.iterrows():
team = Ratings()
team.team_id = int(row["team_id"])
