def create_event(name='TestEvent', creator_email=None):
"""Creates Event and returns its `id`.
:param creator_email:
:param name Name of Event
"""
event = Event(name=name,
start_time=datetime(2016, 4, 8, 12, 30, 45),
end_time=datetime(2016, 4, 9, 12, 30, 45))
if creator_email:
event.creator = User.query.filter_by(email=creator_email).first()
save_to_db(event, 'Event saved')
copyright = Copyright(holder='copyright holder', event=event)
save_to_db(copyright, "Copyright saved")
if creator_email:
# Add creator as Organizer
data = {
'user_email': creator_email,
'user_role': ORGANIZER,
}
DataManager.add_role_to_event(data, event.id, record=False)
return event.id
def test_dumps(self):
props = {
"attr1": "value2",
"attr2": 16
}
event = Event(props)
json_str1 = event.dumps()
self.assertEqual(json_str1, json.dumps(props))
def run(self):
#for i in range(2):
Contributor.fake_feed()
Collective.fake_feed()
Channel.fake_feed()
Tag.fake_feed()
BlogPost.fake_feed()
Podcast.fake_feed()
Section.fake_feed()
Page.fake_feed()
Event.fake_feed()
def post(self):
""" Parse a POST request to the /post endpoint and attempt to
deserialize the request to an event object and persist to database
:return: Success message to the user if no issues
:rtype: str
:raises SQLAlchemyError: If fails roll back transaction and return
error message
"""
jwt = parse_token(request)
if(jwt['role'] is True):
user_id = int(jwt['sub'])
else:
response = jsonify(
message='You do not have permission to invoke this action')
response.status_code = 401
return response
json_data = request.get_json()
start_time = json_data.get('eventTime')
post_schema = PostSchema()
data = post_schema.load(json_data)
event = Event(
data.data['event_id'],
data.data['market_id'],
data.data['selection_id'],
data.data['event_type_id'],
data.data['meta_data'],
data.data['comment'],
json.dumps(data.data['pricedata']),
user_id,
json.dumps(data.data['runnerdata'])
)
db.session.add(event)
event.finish_time = calculate_finish_time(
data.data['event_type_id'],
start_time)
try:
db.session.commit()
scrape_price_data.apply_async(args=[event.id], countdown=10)
pundit = User.query.filter_by(id=user_id).first()
subscriber_list = pundit.subscibers()
for follower in subscriber_list:
redis_key = follower['id']
redis_store.rpush(redis_key, event.id)
user = User.query.filter_by(id=follower['id']).first()
send_notification_mail.apply_async(
args=[pundit, user, event.meta_data])
return {'message': 'Event successfully created'}, 200
except exc.SQLAlchemyError:
db.session.rollback()
return {'error_message': 'Failed to register event'}, 500
def post(self):
create_form = CreateEventForm(self.request.POST)
if not create_form.validate():
context = self.get_context()
context.update({'create_form': create_form})
self.render_response('home.html', **context)
else:
event = Event(**({key: value for key, value in create_form.data.iteritems() if key != 'submit'}))
event.put()
self.redirect("%d/" % event.id)
def put(self, *args, **kwargs):
op = self.get_argument('op')
eid = self.get_argument('rid', '')
if eid:
if op == 'enable':
yield Event.update({"use": 1}, eid)
elif op == 'disable':
yield Event.update({"use": 0}, eid)
else:
self.write({"status": 0})
else:
self.write({"status": 0})
async def periodic_integrity_task(psql_service, timeout):
"""
Fetches a random set of events and applies integrity check
"""
while True:
await asyncio.sleep(int(timeout))
start = datetime.datetime.now()
# run this task only if postgresql is up
if bind_to_service(psql_service['ip_address'], psql_service['port']):
app.logger.info('Integrity Task started at: %s' %
(str(start.strftime('%Y-%m-%d %H:%M:%S'))))
corrupted_events = 0
# get a randomized set to apply checks
events_count = Event.get_count()
randomized_set = Event.get_randomized_set(events_count)
if randomized_set:
for event in randomized_set:
try:
event_integrity_ok = check_quality(event)
# rollback broken transaction if something goes wrong during query
except sqlalchemy.exc.StatementError:
db.session.rollback()
app.logger.warning(
'Rolling back db transaction. Retrying in %s seconds...'
% (str(timeout)))
await asyncio.sleep(int(timeout))
continue
if not event_integrity_ok:
corrupted_events += 1
if corrupted_events:
total_time = int(
(datetime.datetime.now() - start).microseconds / 1000)
app.logger.warning(
'Checked: %s random events in %s ms. Corrupted: %s' %
(str(len(randomized_set)), str(total_time),
str(corrupted_events)))
else:
total_time = int(
(datetime.datetime.now() - start).microseconds / 1000)
app.logger.info(
'Checked: %s random events in %s ms. Everything ok.' %
(str(len(randomized_set)), str(total_time)))
else:
app.logger.info(
'Integrity Task - Something went wrong. Retrying in %s seconds..'
% (str(timeout)))
else:
app.logger.info(
'Integrity Task - Database is down. Retrying in %s seconds..' %
(str(timeout)))
def test_paginating_events(self):
names = []
for i in range(12):
names.append("Event #%s" % i)
for n in names:
Event.create(self.db, **{"name": n})
page1 = Event.paged(self.db, 1, 10)
page2 = Event.paged(self.db, 2, 10)
assert_equal(names[0:10], map(lambda e: e.name.encode("ascii"), page1))
assert_equal(names[10:12], map(lambda e: e.name.encode("ascii"), page2))
def api_list(self):
evt = Event.list_all()
# logging.info("===EVT== 2:: %s" % evt)
list_e = []
for event in evt:
if event.seat_map_url is None or event.seat_map_url == "":
event.seat_map_url = "http://" + app_identity.get_default_version_hostname() + self.uri("download", blob=event.seat_map)
event.put()
if event.photo_url is None or event.photo_url == "":
event.photo_url = "http://" + app_identity.get_default_version_hostname() + self.uri("download", blob=event.photo)
event.put()
list_e.append(event)
evt_messages = Event.to_message(list_e)
self.context['data'] = evt_messages
def link_random_events_to_user(user):
events_from_categories = Event.objects(
categories__in=user.get_categories())
random_events = faker.random.sample(
list(events_from_categories),
round(0.5 + faker.random.betavariate(2, 5) * 10))
user.set_events(random_events)
def create_event(attributes):
start_at = datetime.strptime(attributes['start_at'], DATETIME_FORMAT) - timedelta(hours=UTC_OFFSET)
room = Room(
name=attributes['name'],
teacher=current_user,
role=Room.CONSULTATION
)
event = Event(
name=attributes['name'],
teacher=current_user,
room=room,
start_at=start_at
)
groups = []
for group_id in attributes['groups']:
groups.append(
Group.query.get(group_id)
)
room.groups = groups
db.session.add(room)
db.session.add(event)
db.session.commit()
_get_events()
def check_vote_event(vote):
idea = Idea.query.get(vote.idea_id)
if idea is None:
return
if vote.value > 0 and idea.upvotes % 5 == 0:
save_event(Event(type=EventType.upvotes,
user_id=idea.user_id,
idea_name=idea.title,
data=idea.upvotes,
created=vote.created))
elif idea.votes_count % 10 == 0:
save_event(Event(type=EventType.votes,
user_id=idea.user_id,
idea_name=idea.title,
data=idea.votes_count,
created=vote.created))
def event_registrer():
if request.method == 'OPTIONS':
return jsonify({})
if request.json['type_event'] in ['eventos-saude', 'eventos-bem-estar', 'eventos-informativo']:
name = request.json['name']
descripton = request.json['descripton']
date = datetime.strptime(request.json['date'], '%d/%m/%Y').date()
type_event = request.json['type_event']
latitude = request.json['latitude']
longitude = request.json['longitude']
event = Event(
name,
descripton,
date,
type_event,
latitude,
longitude
)
db.session.add(event)
db.session.commit()
result = event_share_schema.dump(
Event.query.filter_by(name=name).first()
)
return jsonify(result)
return jsonify({'error': 'Tipo de evento inválido!'})
def check_idea_change_event(idea):
votes = db.session.query(Vote).filter_by(idea_id=idea.id).filter(Vote.user_id != idea.user_id).all()
for vote in votes:
save_event(Event(type=EventType.idea_changed,
user_id=vote.user_id,
idea_name=idea.title,
created=idea.modified))
def get_event_ids_of_category(cat_id):
"""
Returns a list with all event_ids that have given category (as strings)
"""
events = Event.objects(categories=cat_id)
event_ids = [event.id.__str__() for event in events]
return event_ids
def check_idea_delete_event(idea):
votes = db.session.query(Vote).filter_by(idea_id=idea.id).filter(Vote.user_id != idea.user_id).all()
for vote in votes:
save_event(Event(type=EventType.idea_deleted,
user_id=vote.user_id,
idea_name=idea.title,
created=datetime.utcnow()))
def test_init(self):
props = {
'attr1': 'value1',
'attr2': 15
}
event = Event(props)
self.assertEqual(event.attr1, 'value1')
self.assertEqual(event.attr2, 15)
def __get_event_by_id(self, event_id):
"""Get event by event ID."""
try:
event_model = EventModel.get(EventModel.id == event_id)
event = Event.from_model(event_model)
return event
except DoesNotExist:
raise DbActorError("Event not found.", 404) from DoesNotExist
def __get_events(self):
"""Get all available events."""
events = []
event_models = EventModel.select()
for event_model in event_models:
event = Event.from_model(event_model)
events.append(event)
return events
def init_event(vote):
idea = Idea.query.get(vote.idea_id)
if vote.value > 0 and idea.upvotes % 5 == 0:
event = (Event(type=EventType.upvotes,
user_id=idea.user_id,
idea_name=idea.title,
data=idea.upvotes,
created=vote.created))
db.session.add(event)
db.session.commit()
elif idea.votes_count % 10 == 0:
event = (Event(type=EventType.votes,
user_id=idea.user_id,
idea_name=idea.title,
data=idea.votes_count,
created=vote.created))
db.session.add(event)
db.session.commit()
def get_event():
return Event(name="event1",
start_time=datetime(2003, 8, 4, 12, 30, 45),
end_time=datetime(2003, 9, 4, 12, 30, 45),
location_name='India',
topic='Travel & Outdoor',
sub_topic='Climbing',
has_session_speakers=True,
type='Camp, Trip, or Retreat')
def delete(self, *args, **kwargs):
eid = self.get_argument('rid', '')
if eid:
yield BugEvent.delete_by_query({"event_id": eid})
yield UserEvent.delete_by_query({"event_id": eid})
yield Event.delete_by_id(eid)
self.write({"status": 1})
else:
self.write({"status": 0})
def add_new_event():
event_date = request.form['date']
event_name = request.form['name']
event_guest = request.form['number_of_guest']
event_location = request.form['location']
event_desc = request.form['description']
new_event = Event(event_date, event_name, event_guest, event_location, event_desc, False)
add_event(new_event)
return render_template ('index.html', events=events)
def api_list(self):
evt = Event.list_all()
# logging.info("===EVT== 2:: %s" % evt)
list_e = []
for event in evt:
if event.seat_map_url is None or event.seat_map_url == "":
event.seat_map_url = "http://" + app_identity.get_default_version_hostname(
) + self.uri("download", blob=event.seat_map)
event.put()
if event.photo_url is None or event.photo_url == "":
event.photo_url = "http://" + app_identity.get_default_version_hostname(
) + self.uri("download", blob=event.photo)
event.put()
list_e.append(event)
evt_messages = Event.to_message(list_e)
self.context['data'] = evt_messages
def filter_category(category_id):
category = Category.objects.get(id=category_id)
events = Event.objects(categories__in=[category])
recommended = events[:10]
return render_template('dashboard.html',
name=current_user.email,
events=events,
recommended=recommended,
categories=current_user.categories,
attending=current_user.events)
def create_attendee(event_id):
event = Event.find(db(), event_id)
attendee = Attendee(**request.json)
event.attendees.append(attendee)
try:
db().save_records(event, attendee)
return jsonify(map(lambda a: a.serialize(), event.attendees))
except Exception:
return jsonify(map(lambda a: a.serialize(), event.attendees))
def add_event():
event_name = request.form['event_name']
event_date = request.form['event_date']
event_guests = request.form['event_guests']
event_location = request.form['event_location']
event_description = request.form['event_description']
event_recurring = request.form['event_recurring']
new_event = Event(event_date, event_name, event_guests, event_location, event_description, event_recurring)
add_new_event(new_event)
return render_template('events.html', title="Events List", events=events)
def delete_attendee(event_id):
event = Event.find(db(), event_id)
user_info = request.json
attendee = db().query(Attendee).filter(Attendee.event_id == event_id,
Attendee.name == user_info["name"],
Attendee.email == user_info["email"])
if attendee:
attendee.delete()
return jsonify(map(lambda a: a.serialize(), event.attendees))
def test_restore_event_from_trash(self):
with app.test_request_context():
event = Event(name="event1",
start_time=datetime(2003, 8, 4, 12, 30, 45),
end_time=datetime(2003, 9, 4, 12, 30, 45),
in_trash=True)
save_to_db(event, "Event saved")
restore_event(1)
self.assertEqual(event.in_trash, False)
def test_restore_event_from_trash(self):
with app.test_request_context():
event = Event(name="event1",
start_time=datetime(2003, 8, 4, 12, 30, 45),
end_time=datetime(2003, 9, 4, 12, 30, 45),
deleted_at=datetime.now())
save_to_db(event, "Event saved")
restore_event(1)
self.assertEqual(event.deleted_at, None)
def add_event(data):
if g.user.admin:
dt = datetime.strptime(data["datetime"], "%Y-%m-%d %H:%M")
t = Event(data["name"], dt)
db.session.add(t)
db.session.commit()
return jsonify({"event_id": t.id}), 200
else:
return jsonify({"message": "unauthorized"}), 401
def buildTicket(cls, ticket):
return TicketMessage(
key=ticket.key.urlsafe(),
section=ticket.section,
quantity=ticket.quantity,
price=ticket.price,
scalper_name=cls.buildScalpers(ticket.scalper_name.get()),
sold=ticket.sold,
event=Event.buildEvent(ticket.event.get())
)
def get(self, event_id, bracket_id):
event = Event.get_by_id(event_id)
if not event:
self.redirect(uri_for('home'))
bracket = Bracket.get_by_id(bracket_id)
if not bracket:
self.redirect(uri_for('brackets', event_id=event_id))
bracket.regenerate(bracket.format_code)
self.redirect(uri_for('single-bracket', event_id=event_id, bracket_id=bracket.id))
def create():
event_id = len(events) + 1
event_date = request.form['date']
event_name = request.form['name']
no_of_guests = request.form['no_of_guests']
room = request.form['room']
description = request.form['description']
new_event = Event(event_id, event_date, event_name, no_of_guests, room,
description)
add_new_event(new_event)
return redirect('/events')
def join_event(action, profile, event):
node = Profile.objects(pk=profile).first()
event = Event.objects(pk=event).first()
if not node or not event:
raise Exception('Invalid profile or event')
if action == 'join':
RelationShips.join(node, event)
elif action == 'unjoin':
RelationShips.unjoin(node, event)
else:
raise Exception("Invalid action")
return node
def api_ticket_details(self, e_key=None):
evt = self.util.decode_key(e_key).get()
if evt.seat_map_url is None or evt.seat_map_url == "":
evt.seat_map_url = "http://" + app_identity.get_default_version_hostname() + self.uri("download", blob=evt.seat_map)
evt.put()
if evt.photo_url is None or evt.photo_url == "":
evt.photo_url = "http://" + app_identity.get_default_version_hostname() + self.uri("download", blob=evt.photo)
evt.put()
evt_details = Event.find_event(evt)
self.context['data'] = evt_details
def setUp(self):
self.app = Setup.create_app()
with app.test_request_context():
event = Event(name=UNICODE_STRING,
start_time=datetime(2013, 8, 4, 12, 30, 45),
end_time=datetime(2016, 9, 4, 12, 30, 45))
event.owner = 1
microlocation = Microlocation(name=UNICODE_STRING)
session = Session(title=UNICODE_STRING, long_abstract='descp',
start_time=datetime(2014, 8, 4, 12, 30, 45),
end_time=datetime(2015, 9, 4, 12, 30, 45))
speaker = Speaker(name=UNICODE_STRING, email='*****@*****.**',
organisation='org', country='japan')
sponsor = Sponsor(name=UNICODE_STRING)
save_to_db(event, "Event saved")
save_to_db(microlocation, 'Microlocation saved')
save_to_db(session, 'Session saved')
save_to_db(speaker, 'Speaker saved')
save_to_db(sponsor, 'Sponsor saved')
def event_create(user, user_type, args):
if user_type != 'Organizer':
raise Error(status_code=StatusCode.UNAUTHORIZED,
error_message='Invalid token')
event = Event.query.filter_by(title=args['title']).first()
if event is not None:
raise Error(status_code=StatusCode.BAD_REQUEST,
error_message='Duplicated event')
location = Location.query.filter_by(id=args['location_id'],
owner_id=user.id).first()
if location is None:
raise Error(status_code=StatusCode.BAD_REQUEST,
error_message='Location not belongs to owner')
if args['type'] != 'public' and args['type'] != 'private':
raise Error(status_code=StatusCode.BAD_REQUEST,
error_message='Invalid type of event')
event = Event(
title=args['title'],
description=args['description'],
category=args['category'],
# start_date=datetime.datetime.strptime(args['start_date'], '%d-%m-%Y %H:%M'),
# end_date=datetime.datetime.strptime(args['end_Date'], '%d-%m-%Y %H:%M'),
start_date=args['start_date'],
end_date=args['end_date'],
location_id=location.id,
owner_id=user.id,
type=args['type'],
capacity=args['capacity'])
db.session.add(event)
db.session.commit()
return jsonify({
'message': 'Event created successfully',
'data': event.serialize()
}), 201
def test_add_event_to_trash(self):
with app.test_request_context():
event = Event(name="event1",
start_time=datetime(2003, 8, 4, 12, 30, 45),
end_time=datetime(2003, 9, 4, 12, 30, 45),
in_trash=False)
save_to_db(event, "Event saved")
DataManager.trash_event(1)
url = url_for('events.index_view')
rv = self.app.get(url)
self.assertFalse('event1' in rv.data)
self.assertEqual(event.in_trash, True)
def create_event(name='TestEvent', creator_email=None):
"""Creates Event and returns its `id`.
:param name Name of Event
"""
copyright = Copyright(holder='copyright holder')
event = Event(name=name,
start_time=datetime(2016, 4, 8, 12, 30, 45),
end_time=datetime(2016, 4, 9, 12, 30, 45),
copyright=copyright)
if creator_email:
event.creator = User.query.filter_by(email=creator_email).first()
save_to_db(event, 'Event saved')
if creator_email:
# Add creator as Organizer
data = {
'user_email': creator_email,
'user_role': ORGANIZER,
}
DataManager.add_role_to_event(data, event.id, record=False)
return event.id
def render_response(self, _template, **context):
# Renders a template and writes the result to the response.
# append global context stuff (for navbar etc)
event = context.get('event')
if event:
brackets = Bracket.get_by_event(event.id, order='weightclass_code, name')
context.update({'brackets': brackets})
events = Event.get_all(order='start_date desc')
context['events'] = [{'id': event.id, 'name': event.name} for event in events]
rv = self.jinja2.render_template(_template, **context)
self.response.write(rv)
def get(self, event_id, bracket_id):
event = Event.get_by_id(event_id)
if not event:
self.redirect(uri_for('home'))
bracket = Bracket.get_by_id(bracket_id)
if not bracket:
self.redirect(uri_for('brackets', event_id=event_id))
bots = Bot.get_by_weightclass_registered(bracket.weightclass_code, event.id)
context = {
'event': event,
'bracket': bracket,
'bots': json.dumps([{'id': bot.id, 'name': bot.name} for bot in bots])
}
self.render_response('seed.html', **context)
def get(self, event_id):
event = Event.get_by_id(event_id)
if not event:
logging.warning("Tried to look up bots for event %s, redirecting to home", event_id)
return redirect(uri_for('home'))
bots = Bot.get_by_event(event.id, 'weightclass asc, name asc')
import_form = ImportBotsForm()
add_form = AddBotForm()
context = {
'event': event,
'bots': json.dumps([bot.to_dict() for bot in bots]),
'import_form': import_form,
'add_form': add_form
}
self.render_response('bots.html', **context)
def post(self, event_id):
event = Event.get_by_id(event_id)
if not event:
self.redirect(uri_for('home'))
manual_seed = self.request.POST.get('manual_seeding')
bracket_id = self.request.POST.get('bracket_id')
if not bracket_id:
weightclass = Weightclass.get_by_code(self.request.POST['weightclass'])
if not weightclass:
raise ValueError("bad weightclass")
format = FORMATS.get(self.request.POST['format'])
if not format:
raise ValueError("bad format")
if format.get('code') == 'roundrobin':
manual_seed = False
name = self.request.POST['name']
bracket = Bracket(event_id=event.id,
match_length=weightclass.default_match_length,
format_code=format['code'],
weightclass_code=weightclass.code,
name=name,
manual_seed=manual_seed or False,
generated=False)
bracket.put()
else:
bracket = Bracket.get_by_id(bracket_id)
seeding = self.request.POST.getall('seeding[]')
if manual_seed and not seeding:
self.redirect(uri_for('manual-seed', event_id=event_id, bracket_id=bracket.id))
else:
result = bracket.generate(seeding)
if result:
bracket.generated=True
bracket.put()
else:
bracket.delete()
self.redirect(uri_for('single-bracket', event_id=event_id, bracket_id=bracket.id), abort=False)
def get(self, event_id):
if isinstance(event_id, basestring):
event_id = int(event_id)
event = Event.get_by_id(event_id)
if not event:
return redirect(uri_for('home'))
bots = Bot.get_by_event(event_id)
registered_bots = [bot for bot in bots if bot.registered_ind == 'Y']
brackets = Bracket.get_by_event(event.id)
context = {
'event': event,
'bots_registered': len(registered_bots),
'bots_total': len(bots),
'brackets': brackets
}
self.render_response('event.html', **context)
def get(self, event_id):
event = Event.get_by_id(event_id)
if not event:
self.redirect(uri_for('home'))
weightclasses = Weightclass.get_by_event(event_id)
generate_form = GenerateBracketForm()
weightclass_choices = []
brackets = {}
for weightclass in weightclasses:
bots = Bot.get_by_weightclass_registered(weightclass.code, event.id)
if len(bots) > 1:
weightclass_choices.append((weightclass.code, '%s (%d bots)' % (weightclass.name, len(bots))))
brackets[weightclass.name] = []
weightclass_brackets = Bracket.get_by_event_and_class(event_id, weightclass.code)
for bracket in weightclass_brackets:
matches = Match.get_by_bracket(bracket.id)
completed_matches = [match for match in matches if match.winning_bot_id]
bots = Bot.get_by_bracket(bracket.id)
brackets[weightclass.name].append({
'total_matches': len(matches) if matches else 0,
'completed_matches': len(completed_matches) if completed_matches else 0,
'total_bots': len(bots) if bots else 0,
'bracket': bracket,
'format': FORMATS.get(bracket.format_code)
})
generate_form.weightclass.choices = weightclass_choices
context = {
'event_brackets': brackets,
'event': event,
'generate_form': generate_form,
'weightclasses': weightclasses
}
self.render_response('brackets.html', **context)
def create_event():
event = Event.create(db(), **request.json)
return jsonify({"success": True,
"event": event.serialize()})
def api_search(self, search_term=None):
result = Event.search(search_term)
self.context['data'] = result
def get(self, event_id, bracket_id):
event = Event.get_by_id(event_id)
bracket = Bracket.get_by_id(bracket_id)
weightclass = Weightclass.get_by_code(bracket.weightclass_code)
format = FORMATS.get(bracket.format_code)
matches = Match.get_by_bracket(bracket_id)
bots = Bot.get_by_bracket(bracket_id)
bots.sort(key=lambda x: x.id)
if bracket.manual_seed and not bracket.generated:
self.redirect(uri_for('manual-seed', event_id=event_id, bracket_id=bracket.id))
for match in matches:
match.populate_bot_entities()
ordered_matches = {'A': []}
rounds = {'A': []}
a_final_round = None
b_final_round = None
a_winner = None
b_winner = None
final_round = None
margin_top = None
if bracket.format_code != ROUND_ROBIN:
if bracket.format_code == DOUBLE_ELIMINATION:
ordered_matches['B'] = []
rounds['B'] = []
for match in matches:
ordered_matches[match.bracket_side].append(match)
# sort A side matches ascending by round, match number
ordered_matches['A'] = sorted(ordered_matches['A'], key=attrgetter('round', 'number'))
number_first_round_matches = sum(1 for m in ordered_matches['A'] if m.round == 'A')
if bracket.format_code == SINGLE_ELIMINATION:
a_final_round = chr(65+int((2*math.log(number_first_round_matches, 2))))
final_round = chr(67+int((2*math.log(number_first_round_matches, 2))))
else:
a_final_round = chr(67+int((2*math.log(number_first_round_matches, 2))))
final_round = chr(69+int((2*math.log(number_first_round_matches, 2))))
a_winner = ordered_matches['A'][-1].winning_bot_id
a_winner = Bot.get_by_id(a_winner) if a_winner else None
if ordered_matches.get('B'):
# sort B side matches desc by round, match number
ordered_matches['B'] = sorted(ordered_matches['B'], key=attrgetter('round', 'number'), reverse=True)
b_final_round = chr(66+int((4*(math.log(number_first_round_matches,2)))))
for match in ordered_matches.get('B'):
if match.round not in rounds['B']:
rounds['B'].append(match.round)
# determine b side winner, if applicable
b_winner = ordered_matches['B'][0].winning_bot_id
b_winner = Bot.get_by_id(b_winner) if b_winner else None
for match in ordered_matches.get('A'):
if match.round not in rounds['A']:
rounds['A'].append(match.round)
else:
# don't care for round robin about sort
ordered_matches['A'] = matches
number_first_round_matches = sum(1 for m in ordered_matches['A'] if m.round == 'A')
if bracket.format_code != SINGLE_ELIMINATION:
if number_first_round_matches <= 4:
margin_top = "0px"
elif number_first_round_matches <= 8:
margin_top = "-50px"
elif number_first_round_matches <= 16:
margin_top = "-150px"
elif number_first_round_matches <= 32:
margin_top = "-400px"
else:
margin_top = "0px"
context = {
'format': format,
'bracket': bracket,
'weightclass': weightclass,
'matches': ordered_matches,
'rounds': rounds,
'a_final_round': a_final_round,
'b_final_round': b_final_round,
'final_round': final_round,
'a_winner': a_winner,
'b_winner': b_winner,
'number_first_round_matches': number_first_round_matches,
'margin_top': margin_top,
'event': event,
'bots': bots
}
self.render_response('single-bracket.html', **context)
def import_data(file_path, creator_id, task_handle):
with open(file_path, 'r') as xml_file:
string = xml_file.read().replace('\n', '')
update_status(task_handle, 'Parsing XML file')
conference_object = PentabarfParser.parse(string)
update_status(task_handle, 'Processing event')
event = Event()
event.start_time = conference_object.start
event.end_time = conference_object.end
event.has_session_speakers = True
event.name = conference_object.title
event.location_name = conference_object.venue # + ', ' + conference_object.city
event.searchable_location_name = conference_object.city
event.state = 'Published'
event.privacy = 'public'
db.session.add(event)
event_time_updated = False
update_status(task_handle, 'Adding sessions')
for day_object in conference_object.day_objects:
for room_object in day_object.room_objects:
microlocation, _ = get_or_create(Microlocation, event_id=event.id, name=room_object.name)
for event_object in room_object.event_objects:
session_type_id = None
if event_object.type:
session_type, _ = get_or_create(SessionType, event_id=event.id,
name=event_object.type, length=str(30)) # TODO: hardcoded here
session_type_id = session_type.id
track_id = None
if event_object.track:
string_to_hash = event_object.track
seed = int('100'.join(list(str(ord(character)) for character in string_to_hash)))
random.seed(seed)
color = "#%06x" % random.randint(0, 0xFFFFFF)
track, _ = get_or_create(Track, event_id=event.id, name=event_object.track, color=color)
track_id = track.id
session = Session()
session.track_id = track_id
session.microlocation_id = microlocation.id
session.session_type_id = session_type_id
session.title = event_object.title
session.short_abstract = event_object.abstract
session.long_abstract = event_object.description
session.level = getattr(event_object, 'level', None) # https://github.com/niranjan94/python-pentabarf-xml/issues/3
session.start_time = event_object.date + string_to_timedelta(event_object.start)
session.end_time = session.start_time + string_to_timedelta(event_object.duration)
session.slides = event_object.slides_url
session.video = event_object.video_url
session.audio = event_object.audio_url
session.signup_url = event_object.conf_url
session.event_id = event.id
session.state = 'accepted'
session.speakers = []
save_to_db(session, 'Session Updated')
if not event_time_updated:
event.start_time = None
event.end_time = None
event_time_updated = True
if not event.start_time or session.start_time < event.start_time:
event.start_time = session.start_time
if not event.end_time or session.end_time > event.end_time:
event.end_time = session.end_time
for person_object in event_object.person_objects:
name_mix = person_object.name + ' ' + conference_object.title
email = ''.join(x for x in name_mix.title() if not x.isspace()) + '@example.com'
speaker = Speaker(name=person_object.name, event_id=event.id, email=email,
country='Earth',
organisation='')
db.session.add(speaker)
session.speakers.append(speaker)
db.session.commit()
update_status(task_handle, 'Added session "' + session.title + '"')
update_status(task_handle, 'Saving data')
save_to_db(event)
update_status(task_handle, 'Finalizing')
own_event(event=event, user_id=creator_id)
return event
def show_event(event_id):
event = Event.find_with_associations(db(), event_id)
return jsonify(event.serialize())
def import_data(file_path, creator_id, task_handle):
update_status(task_handle, 'Parsing iCal file')
file = open(file_path, 'rb')
calendar = Calendar.from_ical(file.read())
update_status(task_handle, 'Processing event')
event = Event()
if 'X-WR-CALNAME' in calendar:
event.name = get_valid_event_name(calendar.decoded('X-WR-CALNAME'))
if not event.name and 'X-WR-CALDESC' in calendar:
event.name = get_valid_event_name(calendar.decoded('X-WR-CALDESC'))
for session in calendar.walk('vevent'):
if not event.name:
event.name = get_valid_event_name(session.decoded('UID'))
start_time = session.decoded('dtstart')
end_time = session.decoded('dtend')
if not event.start_time or start_time < event.start_time:
event.start_time = start_time
if not event.end_time or end_time > event.end_time:
event.end_time = end_time
if not event.name:
event.name = 'Un-named Event'
# Event name set
if 'X-WR-TIMEZONE' in calendar:
event.timezone = calendar.decoded('X-WR-TIMEZONE')
event.has_session_speakers = True
event.state = 'Published'
event.privacy = 'public'
db.session.add(event)
update_status(task_handle, 'Adding sessions')
for session_block in calendar.walk('vevent'):
track_id = None
if 'CATEGORIES' in session_block:
categories = session_block['CATEGORIES']
string_to_hash = categories if not hasattr(categories, '__iter__') else categories[0]
seed = int('100'.join(list(str(ord(character)) for character in string_to_hash)))
random.seed(seed)
color = "#%06x" % random.randint(0, 0xFFFFFF)
track, _ = get_or_create(Track, event_id=event.id, name=string_to_hash, color=color)
track_id = track.id
microlocation, _ = get_or_create(Microlocation, event_id=event.id, name=session_block.decoded('location'))
session = Session()
session.track_id = track_id
session.microlocation_id = microlocation.id
session.title = session_block.decoded('summary')
session.short_abstract = session_block.decoded('description')
session.start_time = session_block.decoded('dtstart')
session.end_time = session_block.decoded('dtend')
session.signup_url = session_block.decoded('url')
session.event_id = event.id
session.state = 'accepted'
session.speakers = []
save_to_db(session, 'Session Updated')
attendees = []
if 'attendee' in session_block:
attendees_dirty = session_block['attendee']
if hasattr(attendees_dirty, '__iter__'):
for attendee in attendees_dirty:
attendees.append((attendee.params['CN'], attendee))
else:
attendees.append((attendees_dirty.params['CN'], attendees_dirty))
for attendee in attendees:
speaker = Speaker(name=attendee[0], event_id=event.id, email=attendee[1].replace('MAILTO:', ''),
country='Earth',
organisation='')
db.session.add(speaker)
session.speakers.append(speaker)
db.session.commit()
update_status(task_handle, 'Added session "' + session.title + '"')
update_status(task_handle, 'Saving data')
save_to_db(event)
update_status(task_handle, 'Finalizing')
own_event(event=event, user_id=creator_id)
return event
def show_events():
events = Event.paged_with_associations(db(), page_number(request), 10)
return jsonify(map(lambda event: event.serialize(), events))
def api_uploads(self):
evt = Event.query().get()
uri = "http://" + app_identity.get_default_version_hostname() + self.uri("download", blob=evt.photo)
return uri
def save_event_from_json(json, event_id=None):
"""
Save an event from a wizard json
:param event_id:
:param json:
:return:
"""
event_data = json['event']
state = json['state']
if event_id and represents_int(event_id):
event = DataGetter.get_event(event_id)
is_edit = True
else:
event = Event()
is_edit = False
start_time = get_event_time_field_format(event_data, 'start_time')
end_time = get_event_time_field_format(event_data, 'end_time')
if event_data['name'].strip() == '' or not start_time or not end_time:
abort(400)
if start_time > end_time:
abort(400)
event.name = event_data['name']
if event_data['event_url'].strip() != "":
if not event_data['event_url'].startswith("http"):
event.event_url = "https://" + event_data['event_url']
else:
event.event_url = event_data['event_url']
else:
event.event_url = ""
event.location_name = event_data['location_name']
event.show_map = 1 if event_data['show_map'] else 0
event.start_time = start_time
event.end_time = end_time
event.timezone = event_data['timezone']
event.description = event_data['description']
event.privacy = event_data['privacy']
event.type = event_data['type']
event.topic = event_data['topic']
event.sub_topic = event_data['sub_topic']
event.latitude = event_data['latitude']
event.longitude = event_data['longitude']
event.searchable_location_name = get_searchable_location_name(event)
event.state = state if event_data['location_name'].strip() != '' else 'Draft'
event.organizer_description = event_data['organizer_description'] if event_data['has_organizer_info'] else ''
event.organizer_name = event_data['organizer_name'] if event_data['has_organizer_info'] else ''
event.code_of_conduct = event_data['code_of_conduct'] if event_data['has_code_of_conduct'] else ''
save_to_db(event, "Event Saved")
record_activity('create_event', event_id=event.id)
db.session.add(event)
db.session.flush()
db.session.refresh(event)
copyright = event.copyright
if not event.copyright:
copyright = EventCopyright(event=event)
year = datetime.now().year
copyright.licence = event_data['copyright']['licence']
_, _, licence_url, logo, _ = EVENT_LICENCES.get(copyright.licence, ('',) * 5)
copyright.holder = event.organizer_name
copyright.year = year
copyright.logo = logo
copyright.licence_url = licence_url
save_social_links(event_data['social_links'], event)
event.ticket_include = event_data['ticket_include']
if event.ticket_include:
event.ticket_url = url_for('event_detail.display_event_detail_home', identifier=event.identifier, _external=True)
save_tickets(event_data['tickets'], event)
else:
event.ticket_url = event_data['ticket_url']
event.discount_code_id = event_data['discount_code_id']
event.payment_country = event_data['payment_country']
event.payment_currency = event_data['payment_currency']
event.pay_by_paypal = event_data['pay_by_paypal']
event.pay_by_cheque = event_data['pay_by_cheque']
event.pay_by_bank = event_data['pay_by_bank']
event.pay_onsite = event_data['pay_onsite']
event.pay_by_stripe = event_data['pay_by_stripe']
event.cheque_details = event_data['cheque_details'] if event.pay_by_cheque else ''
event.bank_details = event_data['bank_details'] if event.pay_by_bank else ''
event.onsite_details = event_data['onsite_details'] if event.pay_onsite else ''
if event.pay_by_paypal:
event.paypal_email = event_data['paypal_email']
else:
event.paypal_email = None
if event.pay_by_stripe and event_data['stripe']['linked']:
stripe_data = event_data['stripe']
stripe = event.stripe
if not stripe:
stripe = StripeAuthorization(event_id=event.id)
stripe.stripe_secret_key = stripe_data['stripe_secret_key']
stripe.stripe_refresh_token = stripe_data['stripe_refresh_token']
stripe.stripe_publishable_key = stripe_data['stripe_publishable_key']
stripe.stripe_user_id = stripe_data['stripe_user_id']
stripe.stripe_email = stripe_data['stripe_email']
db.session.add(stripe)
else:
if event.stripe:
db.session.delete(event.stripe)
event.tax_allow = bool(event_data['tax_allow'] == 1)
if event.tax_allow:
tax_data = event_data['tax']
tax = event.tax
if not tax:
tax = Tax(event_id=event.id)
tax.country = tax_data['country']
tax.tax_name = tax_data['tax_name']
tax.send_invoice = tax_data['send_invoice']
tax.tax_id = tax_data['tax_id']
tax.registered_company = tax_data['registered_company']
tax.address = tax_data['address']
tax.state = tax_data['state']
tax.zip = tax_data['zip']
tax.tax_include_in_price = tax_data['tax_include_in_price']
tax.invoice_footer = tax_data['invoice_footer']
db.session.add(tax)
else:
if event.tax:
db.session.delete(event.tax)
if event.logo != event_data['logo']:
if event_data['logo'] and event_data['logo'].strip() != '':
event.logo = save_logo(event_data['logo'], event.id)
elif event.logo != '':
event.logo = ''
save_to_db(event)
image_sizes = DataGetter.get_image_sizes_by_type(type='event')
if not image_sizes:
image_sizes = ImageSizes(full_width=1300,
full_height=500,
full_aspect='on',
icon_width=75,
icon_height=30,
icon_aspect='on',
thumbnail_width=500,
thumbnail_height=200,
thumbnail_aspect='on',
type='event')
save_to_db(image_sizes, "Image Sizes Saved")
if event.background_url != event_data['background_url']:
if event_data['background_url'] and event_data['background_url'].strip() != '':
background_url = event_data['background_url']
jpg_image = convert_background_to_jpg(background_url)
event.background_url = save_untouched_background(background_url, event.id)
event.large = save_resized_background(jpg_image, event.id, 'large', image_sizes)
event.thumbnail = save_resized_background(jpg_image, event.id, 'thumbnail', image_sizes)
event.icon = save_resized_background(jpg_image, event.id, 'icon', image_sizes)
os.remove(jpg_image)
save_to_db(event)
elif event.background_url != '':
event.background_url = ''
event.large = ''
event.thumbnail = ''
event.icon = ''
save_to_db(event)
if not is_edit:
role = Role.query.filter_by(name=ORGANIZER).first()
uer = UsersEventsRoles(login.current_user, event, role)
if save_to_db(uer, "Event saved"):
new_email_notification_setting = EmailNotification(next_event=1,
new_paper=1,
session_schedule=1,
session_accept_reject=1,
after_ticket_purchase=1,
user_id=login.current_user.id,
event_id=event.id)
save_to_db(new_email_notification_setting, "EmailSetting Saved")
return {
'event_id': event.id
}
