def test_create_event(notify_db, notify_db_session):
assert Event.query.count() == 0
data = {"event_type": "sucessful_login", "data": {"something": "random", "in_fact": "could be anything"}}
event = Event(**data)
dao_create_event(event)
assert Event.query.count() == 1
event_from_db = Event.query.first()
assert event == event_from_db
def test_create_event(notify_db, notify_db_session):
assert Event.query.count() == 0
data = {
'event_type': 'sucessful_login',
'data': {'something': 'random', 'in_fact': 'could be anything'}
}
event = Event(**data)
dao_create_event(event)
assert Event.query.count() == 1
event_from_db = Event.query.first()
assert event == event_from_db
def test_create_event(notify_db, notify_db_session):
assert Event.query.count() == 0
data = {
"event_type": "sucessful_login",
"data": {
"something": "random",
"in_fact": "could be anything"
},
}
event = Event(**data)
dao_create_event(event)
assert Event.query.count() == 1
event_from_db = Event.query.first()
assert event == event_from_db
def create_event(title='test title',
description='test description',
event_type_id=None,
fee=5,
conc_fee=3,
multi_day_fee=12,
multi_day_conc_fee=10,
old_id=1,
event_dates=None,
venue_id=None):
if not event_type_id:
event_type = EventType.query.filter_by(event_type='workshop').first()
if not event_type:
event_type = create_event_type(event_type='workshop')
event_type_id = str(event_type.id)
if not venue_id:
venue = Venue.query.first()
if not venue:
venue = create_venue()
venue_id = str(venue.id)
data = {
'old_id': old_id,
'event_type_id': event_type_id,
'title': title,
'description': description,
'fee': fee,
'conc_fee': conc_fee,
'multi_day_fee': multi_day_fee,
'multi_day_conc_fee': multi_day_conc_fee,
'venue_id': venue_id,
}
event = Event(**data)
if event_dates:
event.event_dates.extend(event_dates)
dao_create_event(event)
return event
def create_event():
data = request.get_json(force=True)
event_year = None
validate(data, post_create_event_schema)
try:
dao_get_event_type_by_id(data['event_type_id'])
except NoResultFound:
raise InvalidRequest(
'event type not found: {}'.format(data['event_type_id']), 400)
try:
dao_get_venue_by_id(data['venue_id'])
except NoResultFound:
raise InvalidRequest('venue not found: {}'.format(data['venue_id']),
400)
event = Event(
event_type_id=data['event_type_id'],
title=data['title'],
sub_title=data.get('sub_title'),
description=data['description'],
booking_code='',
fee=data.get('fee'),
conc_fee=data.get('conc_fee'),
multi_day_fee=data.get('multi_day_fee'),
multi_day_conc_fee=data.get('multi_day_conc_fee'),
venue_id=data.get('venue_id'),
event_state=data.get('event_state', DRAFT),
remote_access=data.get('remote_access'),
remote_pw=data.get('remote_pw'),
)
for event_date in data.get('event_dates'):
if not event_year:
event_year = event_date['event_date'].split('-')[0]
speakers = []
for s in event_date.get('speakers', []):
speaker = dao_get_speaker_by_id(s['speaker_id'])
speakers.append(speaker)
e = EventDate(event_datetime=event_date['event_date'],
end_time=None if event_date.get('end_time') == '' else
event_date.get('end_time'),
speakers=speakers)
dao_create_event_date(e)
event.event_dates.append(e)
dao_create_event(event)
image_filename = data.get('image_filename')
image_data = data.get('image_data')
storage = Storage(current_app.config['STORAGE'])
if image_data:
target_image_filename = '{}/{}'.format(event_year, str(event.id))
storage.upload_blob_from_base64string(image_filename,
target_image_filename,
base64.b64decode(image_data))
image_filename = target_image_filename
elif image_filename:
if not storage.blob_exists(image_filename):
raise InvalidRequest('{} does not exist'.format(image_filename),
400)
event.image_filename = image_filename
dao_update_event(event.id, image_filename=image_filename)
if event.fee and event.fee > 0 and event.event_state in [READY, APPROVED]:
paypal_tasks.create_update_paypal_button_task.apply_async(
(str(event.id), ))
return jsonify(event.serialize()), 201
def import_events():
data = request.get_json(force=True)
validate(data, post_import_events_schema)
errors = []
events = []
for item in data:
err = ''
event = Event.query.filter(Event.old_id == item['id']).first()
if not event:
speakers = []
event_type = dao_get_event_type_by_old_id(item['Type'])
if not event_type:
err = '{} event type not found: {}'.format(
item['id'], item['Type'])
current_app.logger.info(err)
errors.append(err)
if item['Speaker']:
for s in re.split(r' and | & ', item['Speaker']):
speaker = dao_get_speaker_by_name(s)
if not speaker:
err = '{} speaker not found: {}'.format(
item['id'], item['Speaker'])
current_app.logger.info(err)
errors.append(err)
else:
speakers.append(speaker)
venue = dao_get_venue_by_old_id(item['venue'])
if not venue:
err = '{} venue not found: {}'.format(item['id'],
item['venue'])
current_app.logger.info(err)
errors.append(err)
if err:
continue
event = Event(old_id=item['id'],
event_type_id=event_type.id,
title=item['Title'],
sub_title=item['SubTitle'],
description=item['Description'],
booking_code=item['BookingCode'],
image_filename=item['ImageFilename'],
fee=item['Fee'],
conc_fee=item['ConcFee'],
multi_day_fee=item['MultiDayFee'],
multi_day_conc_fee=item['MultiDayConcFee'],
duration=item['Duration'],
venue_id=venue.id,
event_state=APPROVED)
def add_event_date(event_datetime):
event_date = EventDate(
event_datetime=event_datetime,
duration=item['Duration'],
fee=item['Fee'],
conc_fee=item['ConcFee'],
multi_day_fee=item['MultiDayFee'],
multi_day_conc_fee=item['MultiDayConcFee'],
venue_id=venue.id)
dao_create_event_date(event_date, speakers)
event.event_dates.append(event_date)
add_event_date(item['StartDate'])
for i in range(2, 5):
if item['StartDate{}'.format(i)] > '0000-00-00 00:00:00':
add_event_date(item['StartDate{}'.format(i)])
events.append(event)
dao_create_event(event)
current_app.logger.info(u'added event {} - {}'.format(
event.old_id, event.title))
else:
err = u'event already exists: {} - {}'.format(
event.old_id, event.title)
current_app.logger.info(err)
errors.append(err)
if is_running_locally() and item[
'ImageFilename'] and item['ImageFilename'] != '../spacer.gif':
storage = Storage(current_app.config['STORAGE'])
if not storage.blob_exists(item['ImageFilename']):
fname = "./data/events/{}".format(item['ImageFilename'])
if os.path.isfile(fname):
storage.upload_blob(fname, item['ImageFilename'])
else:
err = '{} not found for {}'.format(fname, event.old_id)
current_app.logger.info(err)
errors.append(err)
else:
current_app.logger.info('{} found'.format(
item['ImageFilename']))
res = {"events": [e.serialize() for e in events]}
if errors:
res['errors'] = errors
return jsonify(res), 201 if events else 400 if errors else 200
def create_event():
data = request.get_json()
event = event_schema.load(data).data
dao_create_event(event)
return jsonify(data=event_schema.dump(event).data), 201
