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 }