def create_event(form_data, organization_id):
event = Event(name=form_data["name"],
date=form_data["date"],
summary=form_data["summary"],
location=form_data["location"],
organization_id=organization_id)
event.presenters = get_users(form_data["presenters"])
return event
def create_scheduleitem(event_id):
user_id = auth.check_token( request.headers.get('session') )
if not user_id:
return "Unauthorized request: Bad session token", 401
organizer = Organizer.find_id( user_id )
if not organizer:
return "Unauthorized request: User doesn't have permission", 401
event = Event.find_event( event_id )
if not event:
return "Event not found", 404
body = request.get_json()
schedule = ScheduleItem(
title=body.get('title'),
location=body.get('location'),
time = dateParser.parse( body.get('time') )
)
event.schedule.append(schedule)
event.save()
event.reload()
return event.to_json()
def update_discount(event_id, discount_id):
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return send_error("Unauthorized request: Bad session token", 401)
user = Organizer.find_id(user_id)
if not user or user.type != "organizer":
return send_error("Unauthorized request: User doesn't have permission",
401)
event = Event.find_id(event_id)
if not event:
return send_error("Event not found", 404)
discount = Discount.find_id(discount_id)
if not discount:
return send_error("Discount not found", 404)
for key, value in request.get_json().items():
if not key.startswith('_'): # Some security
setattr(discount, key, value)
discount.save()
return discount.to_json()
def create_post(event_id):
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return "Unauthorized request: Bad session token", 401
organizer = Organizer.find_id(user_id)
if not organizer:
return "Unauthorized request: User doesn't have permission", 401
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
body = request.get_json()
post = Post()
post.event = event
post.author = organizer
post.time = datetime.utcnow()
post.image = body.get('image')
post.title = body.get('title')
post.body = body.get('body')
post.notif = body.get('notif')
post.save()
if not post.id:
return "Error creating post", 500
# If post.notif, send text message to all attendees
return post.to_json()
def update_scheduleitem(event_id, index):
index = int(index)
user_id = auth.check_token( request.headers.get('session') )
if not user_id:
return "Unauthorized request: Bad session token", 401
user = Organizer.find_id( user_id )
if not user:
return "Unauthorized request: User doesn't have permission", 401
event = Event.find_event( event_id )
if not event:
return "Event not found", 404
if not (0 <= index < len(event.schedule)):
return "Schedule Item not found", 404
schedule = event.schedule[index]
for key, value in request.get_json().items():
if not key.startswith('_'): # Some security
setattr(schedule, key, value)
event.schedule[index] = schedule;
return event.to_json()
def test_get(self):
with app.test_request_context():
r = json.loads(EventREST().get().data)
self.assertEquals(len(r), 17)
eid = Event.query(
Event.watchword == u'Ундервуд в Улан-Удэ'
).get().key.id()
r = json.loads(EventREST().get(eid).data)
self.assertEquals(r['watchword'], u'Ундервуд в Улан-Удэ')
def get(self, id=None):
if id is None:
args = request.args
count = int(args.get("count", 15))
offset = int(args.get("offset", 0))
d = args.get("date", date.today().strftime(DF)).split("-")
dt = date(int(d[0]), int(d[1]), int(d[2]))
tagids = args.getlist("tags")
if tagids:
tagkeys = [ndb.Key("Tag", int(id)) for id in tagids]
events = Event.query(ndb.AND(Event.intervals.start_date == dt, Event.tags.IN(tagkeys))).fetch()
else:
events = Event.query(Event.intervals.start_date == dt).fetch(count + 1, offset=offset)
r = [to_dict(e, dt) for e in events]
more = len(r) > count # Flag shows there are more results to display
res = {"more": more, "events": r[:-1] if more else r}
else:
res = to_dict(Event.get_by_id(int(id)))
return Response(json.dumps(res), mimetype="application/json")
def get_attendees(event_id, attendee_type):
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return "Unauthorized request: Bad session token", 401
user = Organizer.find_id(user_id)
if not user:
return "Unauthorized request: User doesn't have permission", 401
if not event_id:
return "Event ID required", 400
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
attendee_type = attendee_type.lower()
if attendee_type not in ['attendees', 'students', 'mentors', 'organizers']:
return "Invalid Attendee Type", 404
attendees = None
if attendee_type == 'attendees':
attendees = {
'students': [],
'mentors': [],
'organizers': [],
'checkins': []
}
for usr in User.objects(events=event.id):
if usr.type in ['student', 'mentor', 'organizer']:
attendees[usr.type + 's'].append(usr.to_dict())
else:
if not attendees['other']:
attendees['other'] = []
attendees['other'].append(usr.to_dict())
for usr in User.objects(checkins=event.id):
attendees['checkins'].append(usr.to_dict())
else:
attendees = []
attendee_cls = None
if attendee_type == 'students':
attendee_cls = Student
elif attendee_type == 'mentors':
attendee_cls = Mentor
elif attendee_type == 'organizers':
attendee_cls = Organizer
else:
attendee_cls = User
for usr in attendee_cls.objects(events=event.id):
attendees.append(usr.to_dict())
return json.dumps(attendees), 200, jsonType
def get_discount(event_id, discount_code):
event = Event.find_id(event_id)
if not event:
return send_error("Event not found", 404)
discount = Discount.find_id(discount_code)
if not discount:
discount = Discount.objects(code=discount_code.lower(), event=event)
if not discount:
return send_error("Discount not found", 404)
return discount[0].to_json()
def setUp(self):
db.create_all()
db.session.add(
Event(id=1,
eb_id='5',
name='Check',
image='https://png.pngtree.com/svg/20161216/5935bddf9c.png',
desc='Check check',
html='<p>Check check</p>',
url='https://png.pngtree.com/svg/20161216/5935bddf9c.png',
address='Check city, Atlanta',
lat=0,
lng=0))
db.session.commit()
def remove_event(event_id):
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return "Unauthorized request: Bad session token", 401
user = Organizer.find_id(user_id)
if not user:
return "Unauthorized request: User doesn't have permission", 401
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
event.delete()
return 'Event deleted'
def add_event():
request_json = request.get_json()
auth_token = request_json['auth_token']
user = User.verify_auth_token(auth_token)
if not user:
return json.dumps({'status': 0, 'error': "Authentication Failed"})
elif not user.isMaster:
return json.dumps({'status': 0, 'error': "Access Denied"})
else:
lat = request_json['gps'][0]
lon = request_json['gps'][1]
user_id = user.id
new_event = Event(lat=lat, lon=lon, user_id=user_id)
db.session.add(new_event)
db.session.commit()
return json.dumps({'status': 1})
def sender_email():
events = Event.get(all=True,
alerted=False,
date_appointed__lte=datetime.now() + timedelta(hours=1))
if events is None:
print('Ничего нет')
else:
for event in events:
print(
'Отправляю сообщение!'
) #Сообщение отправляется дважды по причине того, что активне Debug
SendMail(
'Скоро что-то произойдёт..',
f'Менее чем через час у вас должно произойти событие с наименованием "{event.title}"',
event.user.email)
event.update(alerted=True)
def unregister(event_id):
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return "Unauthorized request: Bad session token", 401
user = User.find_id(user_id)
if not user:
return "Unauthorized request: User doesn't have permission", 401
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
if event in user.events:
user.events.remove(event)
user.save()
return json.dumps({"status": "removed"}), 200, jsonType
def test_to_dict(self):
from backend.views.events import to_dict
e = Event.query(Event.watchword == u'Ундервуд в Улан-Удэ').get()
self.assertEquals(to_dict(e), {
'item_id': e.key.id(), 'watchword': e.watchword,
'description': e.description,
'intervals': [{
'start_date': i.start_date.strftime('%Y-%m-%d'),
'start_time': i.start_time.strftime(
'%H:%M') if i.start_time is not None else None,
'end_date': i.start_date.strftime(
'%Y-%m-%d') if i.end_date is not None else None,
'end_time': i.start_time.strftime(
'%H:%M') if i.end_time is not None else None,
} for i in e.intervals],
'company': e.company.id(),
'tags': [ c.id() for c in e.tags],
});
def register_mentor(event_id):
sg = sendgrid.SendGridClient('gopilot', app.config["SENDGRID_PASS"])
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
user = Mentor()
for key, value in request.get_json().items():
if key == "password":
setattr(user, key,
bcrypt.hashpw(value.encode('utf-8'), bcrypt.gensalt()))
elif not key.startswith('_') and not key == "id": # Some security
setattr(user, key, value)
user.events.append(event)
user.save()
message = sendgrid.Mail()
message.add_to(user.name + "<" + user.email + ">")
message.set_from("Pilot <*****@*****.**>")
message.set_subject("Thanks for signing up to mentor at " + event.name +
"!")
email_html = render_template(
'mentor_registration.html',
event_name=event.name,
first_name=user.name.split(' ')[0],
subject="Thanks for signing up to mentor at for " + event.name + "!")
message.set_html(email_html)
email_text = render_template(
'mentor_registration.txt',
event_name=event.name,
first_name=user.name.split(' ')[0],
subject="Thanks for signing up to mentor at " + event.name + "!")
message.set_text(email_text)
if not app.config['TESTING']:
status, msg = sg.send(message)
print(status, msg)
else:
print("Sending message to " + user.email, message)
return user.to_json()
def create_project():
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return "Unauthorized request: Bad session token", 401
user = User.find_id(user_id)
if not user:
return "User not found", 404
project = Project()
event_id = request.json.get('event')
if not event_id:
return "Event is required", 400
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
if not (event in user.events or event.id in user.events):
return "User not attending event", 400
teammate_email = request.json.get('teammate') # A team is required
if not teammate_email:
return "Teammate email is required", 400
teammate = User.objects(email=teammate_email).first()
if not teammate:
return "Teammate not found", 404
if not (event in teammate.events or event.id in teammate.events):
return "Teammate not registered for event", 400
project.name = request.json.get('name')
project.description = request.json.get('description')
project.image = request.json.get('image')
project.event = event
project.team = []
project.team.append(user)
project.team.append(teammate)
project.save()
if not project.id:
return 'Error creating project', 500
return project.select_related(max_depth=1).to_json()
def get_event_projects(event_id):
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
projects = []
query = {}
for key, obj in request.args.iteritems():
query[key] = ObjectId(obj)
query['name__exists'] = True
query['event'] = event.id
for project in Project.objects(**query).only(
'name', 'image', 'description', 'team',
'prize').select_related(max_depth=1):
projects.append(project.to_dict())
return json.dumps(projects), 200, jsonType
def all_discounts(event_id):
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return send_error("Unauthorized request: Bad session token", 401)
user = Organizer.find_id(user_id)
if not user or user.type != "organizer":
return send_error("Unauthorized request: User doesn't have permission",
404)
event = Event.find_id(event_id)
if not event:
return send_error("Event not found", 404)
discounts = []
for d in Discount.objects(event=event):
discounts.append(d.to_dict())
return json.dumps(discounts), 200, jsonType
def get_data(self, request):
answer = {
"ok": 0,
"error": "",
"data": ""
}
if not request.user.is_authenticated:
answer["error"] = "Вам необходимо авторизироваться!"
return Response(answer)
events = Event.get(all=True, user=request.user)
answer['ok'] = 1
if events is None:
answer['data'] = []
else:
serializer = EventSerializer(events, many=True)
answer['data'] = serializer.data
return Response(answer)
def update_event(event_id):
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return "Unauthorized request: Bad session token", 401
user = Organizer.find_id(user_id)
if not user:
return "Unauthorized request: User doesn't have permission", 401
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
for key, value in request.get_json().items():
if not key.startswith('_'): # Some security
setattr(event, key, value)
event.save()
return event.to_json()
def delete_scheduleitem(event_id, index):
index = int(index)
user_id = auth.check_token( request.headers.get('session') )
if not user_id:
return "Unauthorized request: Bad session token", 401
user = Organizer.find_id( user_id )
if not user:
return "Unauthorized request: User doesn't have permission", 401
event = Event.find_event( event_id )
if not event:
return "Event not found", 404
if not (0 <= index < len(event.schedule)):
return "Schedule item not found", 404
event.schedule.pop(index)
return 'Schedule item deleted'
def add_custom_event():
data = request.json
errors = []
event_description = data['event_description']
event_details = data['event_details']
event_picture_url = Picture.query.get(randint(1, 37)).url
data['event_picture_url'] = event_picture_url
custom_event = Event(
name=data['name'],
event_description=f'{event_description}\n{event_details}',
host_id=data['host_id'],
event_date=data['event_date'],
event_planet=data['event_planet'],
event_picture_url=event_picture_url,
category_id=data['category_id'],
is_featured=True)
if errors:
return jsonify(errors)
db.session.add(custom_event)
db.session.commit()
return jsonify(data)
def delete_discount(event_id, discount_id):
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return send_error("Unauthorized request: Bad session token", 401)
user = Organizer.find_id(user_id)
if not user:
return send_error("Unauthorized request: User doesn't have permission",
401)
event = Event.find_id(event_id)
if not event:
return send_error("Event not found", 404)
discount = Discount.find_id(discount_id)
if not discount:
return send_error("Discount not found", 404)
discount.delete()
return 'Discount deleted'
def checkout(event_id):
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return "Unauthorized request: Bad session token", 401
user = Organizer.find_id(user_id)
if not user:
return "Unauthorized request: User doesn't have permission", 401
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
attendee = User.find_id(request.json['attendee_id'])
if not attendee:
return "Attendee not found", 404
if event in attendee.checkins:
attendee.checkins.remove(event)
attendee.save()
return json.dumps({"status": "removed"}), 200, jsonType
def all_posts(event_id):
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return "Unauthorized request: Bad session token", 401
user = User.find_id(user_id)
if not user:
return "User not found", 404
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
attended_ids = [evt.id for evt in user.events]
if not (event.id in attended_ids or user.type == "organizer"):
return "Unauthorized request: User doesn't have permission"
posts = []
for p in Post.objects(event=event):
posts.append(p.to_dict())
return json.dumps(posts), 200, jsonType
def all_scheduleitems(event_id):
user_id = auth.check_token( request.headers.get('session') )
if not user_id:
return "Unauthorized request: Bad session token", 401
user = User.find_id( user_id )
if not user:
return "User not found", 404
event = Event.find_event( event_id )
if not event:
return "Event not found", 404
attended_ids = [ evt.id for evt in user.events ]
if not (event.id in attended_ids or user.type == "organizer"):
return "Unauthorized request: User doesn't have permission"
schedule = []
for s in event.schedule:
schedule.append(s.to_dict())
return json.dumps( schedule ), 200, jsonType
def get_post(event_id, post_id):
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return "Unauthorized request: Bad session token", 401
user = User.find_id(user_id)
if not user:
return "User not found", 404
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
attended_ids = [evt.id for evt in user.events]
if not (event.id in attended_ids or user.type == "organizer"):
return "Unauthorized request: User doesn't have permission"
post = Post.find_id(post_id)
if not post:
return "Post not found", 404
return post.to_json()
def find_tweets(event_id):
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
twitter = Twitter(auth=OAuth2(bearer_token=app.config['TWITTER_TOKEN']))
tweets = twitter.search.tweets(q='#' + event.name,
result_type="recent")['statuses']
data = []
if tweets:
for tweet in tweets:
data.append({
'time':
tweet['created_at'],
'text':
tweet['text'],
'user':
tweet['user']['screen_name'],
'url':
'https://twitter.com/' + tweet['user']['screen_name'] +
"/status/" + str(tweet['id'])
})
# else: ## Fallback - use Topsy API which returns older tweets
# r = requests.get('http://otter.topsy.com/search.json?apikey='+app.config['TOPSY_KEY']+'&perpage=20&q=%23'+event.name)
# tweets = json.loads(r.text)['response']['list']
# for tweet in tweets:
# if not tweet['content'].startswith('RT'):
# data.append({
# 'time': datetime.utcfromtimestamp(tweet['firstpost_date']).strftime("%Y-%m-%d %H:%M:%S"),
# 'text': tweet['content'],
# 'user': tweet['trackback_author_nick'],
# 'url': tweet['url']
# })
return json.dumps(data), 200, jsonType
def create_discount(event_id):
user_id = auth.check_token(request.headers.get('session'))
if not user_id:
return send_error("Unauthorized request: Bad session token", 401)
organizer = Organizer.find_id(user_id)
if not organizer:
return send_error("Unauthorized request: User doesn't have permission",
401)
event = Event.find_id(event_id)
if not event:
return send_error("Event not found", 404)
body = request.get_json()
if Discount.objects(code=body.get('code').lower(), event=event):
return send_error("Code already exists", 400)
discount = Discount()
discount.event = event
discount.title = body.get('title')
discount.amount = body.get('amount')
discount.code = body.get('code').lower()
if body.get('limit'):
discount.limit = body.get('limit')
discount.save()
if not discount.id:
return send_error("Error creating discount", 500)
return discount.to_json()
def add_event(request):
if request.method == 'POST':
id_reservation = request.POST.get('id_reservation')
title = request.POST.get('title')
if title is None or id_reservation is None:
return JsonResponse({
'id_reservation': id_reservation,
'title': title
})
event = Event()
event.id_reservation = id_reservation
event.title = title
event.save()
else:
return JsonResponse({'Response': 'use POST'})
def init_test_db(self):
u1 = User(email='*****@*****.**', password=u'secret').put()
tag1 = Tag(name=u'Концерты').put()
tag2 = Tag(name=u'Блюз-рок').put()
tag3 = Tag(name=u'Психоделический-рок').put()
tag4 = Tag(name=u'Кино').put()
com1 = Company(name=u'Рассвет', employers=[u1], tags=[tag1, tag2, tag3, tag4]).put()
com2 = Company(name=u'Прогресс', tags=[tag4]).put()
e1 = Event(watchword=u'Ундервуд в Улан-Удэ',
description=u'Первый концерт группы в городе',
intervals = [Interval(
start_date=dt.date.today(),
start_time=dt.time(19, 30))])
e1.company = com1
e1.tags.append(tag1)
e1.put()
e2 = Event(watchword=u'Би-2 c единственным концертом в городе',
description=u'Выступление легендарной группы',
intervals = [Interval(
start_date=dt.date.today() + dt.timedelta(1),
start_time=dt.time(19, 30))])
e2.company = com1
e2.tags.append(tag1)
e2.put()
e3 = Event(watchword=u'Да-да, Джим снова жив. Встречайте The Doors. ',
description=u'I\'m crawling king snake',
intervals = [Interval(
start_date=dt.date.today() + dt.timedelta(2),
start_time=dt.time(19, 30))])
e3.company = com1
e3.tags.append(tag1)
e3.tags.append(tag2)
e3.tags.append(tag3)
e3.put()
e4 = Event(watchword=u'Премьера: Хоббит',
description=u'Продолжение легендарной трилогии',
intervals = [
Interval(
start_date=dt.date.today(),
start_time=dt.time(10, 30),
end_date=dt.date.today() + dt.timedelta(1),
end_time=dt.time(12, 30),
),
Interval(
start_date=dt.date.today() + dt.timedelta(1),
start_time=dt.time(10, 30),
end_date=dt.date.today() + dt.timedelta(1),
end_time=dt.time(12, 30),
),
Interval(
start_date=dt.date.today() + dt.timedelta(1),
start_time=dt.time(15, 45),
end_date=dt.date.today() + dt.timedelta(1),
end_time=dt.time(17, 45),
),
Interval(
start_date=dt.date.today() + dt.timedelta(1),
start_time=dt.time(19, 20),
end_date=dt.date.today() + dt.timedelta(1),
end_time=dt.time(21, 20),
),
Interval(
start_date=dt.date.today() + dt.timedelta(1),
start_time=dt.time(22, 30),
end_date=dt.date.today() + dt.timedelta(1),
end_time=dt.time(00, 30),
),
Interval(
start_date=dt.date.today() + dt.timedelta(2),
start_time=dt.time(10, 30),
end_date=dt.date.today() + dt.timedelta(1),
end_time=dt.time(12, 30),
),
])
e4.company = com2
e4.tags.append(tag4)
e4.put()
for i in range(15):
e = Event(watchword=u'Концерт ' + unicode(i) ,
description=u'Описание концерта',
intervals = [Interval(
start_date=dt.date.today(),
start_time=dt.time(10, 30))])
e.company = com1
e.tags.append(tag1)
e.put()
def test_execute_event(self):
mock_model = mock.Mock()
mock_aws = mock.Mock()
with self.assertRaises(NotImplementedError):
Event(mock_model, mock_aws).execute()
def register(event_id):
user = None
discount = False
sg = sendgrid.SendGridClient('gopilot', app.config["SENDGRID_PASS"])
event = Event.find_event(event_id)
if not event:
return "Event not found", 404
price = event.price
if hasattr(request, 'json') and request.json and 'user' in request.json:
if User.objects(email=request.json['user']['email']).first():
return json.dumps({
"status":
"failed",
"reason":
"email",
"message":
"Your email already has a Pilot account."
}), 400, jsonType
print("has user")
user = Student()
user.name = request.json['user']['name']
user.email = request.json['user']['email']
user.complete = False
user.completion_token = random_uuid().hex
if 'discount' in request.json and request.json['discount'] != False:
print("has discount")
# user.save()
discount = checkDiscount(request.json['discount'])
if discount:
price -= discount
print("Charging user %s" % price)
if 'stripe_token' in request.json:
print("has stripe")
stripe.api_key = app.config['STRIPE_KEY']
try:
customer = stripe.Customer.create(
source=request.json['stripe_token'],
description=user.name,
email=user.email)
except stripe.CardError, e:
app.logger.error("Customer Card Error: " + str(e))
err = e.json_body['error']
return json.dumps({
"status":
"failed",
"reason":
err['param'] if ('param' in err) else 'customer',
"message":
err['message']
}), 400, jsonType
user.stripe_id = customer.id
try:
stripe.Charge.create(
amount=(price * 100), ## Cents
currency="usd",
customer=customer.id,
description="Registration for " + event.name)
except stripe.CardError, e:
print("Charge Card Error", e)
err = e.json_body['error']
return json.dumps({
"status":
"failed",
"reason":
err['param'] if ('param' in err) else 'charge',
"message":
err['message']
}), 400, jsonType
