def index(user_id):
orders = orderservice.get(user_id)
if (len(orders) != 0):
return BaseController.send_response_api(
orders, 'orders retrieved successfully')
else:
return BaseController.send_response_api([], 'orders is empty')
def change_name(request, user):
firstname = request.json[
'first_name'] if 'first_name' in request.json else None
lastname = request.json[
'last_name'] if 'last_name' in request.json else ''
booth_info = request.json[
'booth_info'] if 'booth_info' in request.json else None
speaker_job = request.json[
'speaker_job'] if 'speaker_job' in request.json else None
speaker_summary = request.json[
'speaker_summary'] if 'speaker_summary' in request.json else None
if firstname:
payloads = {
'first_name': firstname,
'last_name': lastname,
'booth_info': booth_info,
'speaker_job': speaker_job,
'speaker_summary': speaker_summary,
'user': user
}
else:
return BaseController.send_response_api(None, 'payloads not valid')
result = userservice.change_name(payloads)
if result['error']:
return BaseController.send_error_api(result['data'],
result['message'])
else:
return BaseController.send_response_api(result['data'],
result['message'])
def show(id):
source = sourceservice.show(id)
if source['error']:
return BaseController.send_response_api(source['data'],
source['message'])
return BaseController.send_response_api(source['data'],
source['message'],
source['included'])
def delete(user_id):
user_photo = userphotoservice.delete(user_id)
if user_photo['error']:
return BaseController.send_response_api(None,
'user photo not found')
return BaseController.send_response_api(
None, 'user photo for user id: ' + str(user_id) +
' has been succesfully deleted')
def grant(request):
user_id = request.json['user_id'] if 'user_id' in request.json else None
partner_id = request.json[
'partner_id'] if 'partner_id' in request.json else None
if user_id is None or partner_id is None:
return BaseController.send_response_api(None, 'invalid payload')
result = db.session.query(PartnerPj).filter_by(partner_id=partner_id)
if result.first() is None:
partner = db.session.query(Partner).filter_by(
id=partner_id).first()
if partner:
newPartnerPj = PartnerPj()
newPartnerPj.user_id = user_id
newPartnerPj.partner_id = partner_id
db.session.add(newPartnerPj)
try:
db.session.commit()
new_user = db.session.query(User).filter_by(
id=user_id).update({
'role_id':
ROLE['partner'],
'updated_at':
datetime.datetime.now()
})
db.session.commit()
return BaseController.send_response_api(None, 'pj updated')
except SQLAlchemyError as e:
return BaseController.send_error_api(
None, 'query error occured')
else:
return BaseController.send_error_api(None, 'partner not found')
# revert user role
user = db.session.query(User).filter_by(
id=result.first().user_id).update({'role_id': ROLE['user']})
result.update({
'user_id': user_id,
'updated_at': datetime.datetime.now()
})
try:
db.session.commit()
new_user = db.session.query(User).filter_by(id=user_id).update({
'role_id':
ROLE['partner'],
'updated_at':
datetime.datetime.now()
})
db.session.commit()
return BaseController.send_response_api(None, 'pj updated')
except SQLAlchemyError as e:
return BaseController.send_error_api(None, 'query error occured')
def refreshtoken(request):
refresh_token = request.json[
'refresh_token'] if 'refresh_token' in request.json else None
if refresh_token:
id = userservice.check_refresh_token(refresh_token)
if id:
new_token = userservice.get_new_token(id)
return BaseController.send_response_api(
{
'access_token': new_token['data']['access_token'],
'refresh_token': new_token['data']['refresh_token']
}, 'token successfully refreshed')
return BaseController.send_response_api({'exist': False},
'refresh token not exist')
return BaseController.send_error_api(None, 'refresh token required')
def send_confirmation_email(request):
email = request.json['email'] if 'email' in request.json else None
if email:
user = userservice.get_user(email)
if user is None:
return BaseController.send_error_api(
None, 'User not found, register first')
if user.confirmed:
return BaseController.send_response_api(
None, 'This account has been confirmed, you can login now')
userservice.send_confirmation_email(user)
return BaseController.send_response_api(
None, 'Confirmation email has been sent to %s' % (email))
else:
return BaseController.send_error_api(None, 'Email required')
def show(user_id):
user_photo = userphotoservice.show(user_id)
if user_photo['error']:
return BaseController.send_error_api(user_photo['data'],
user_photo['message'])
return BaseController.send_response_api(user_photo['data'],
user_photo['message'])
def update(request, id):
quota = request.json['quota'] if 'quota' in request.json else 1
discount_amount = request.json[
'discount_amount'] if 'discount_amount' in request.json else 0.1
referal_code = request.json[
'referal_code'] if 'referal_code' in request.json else ''
if quota:
payloads = {
'discount_amount': discount_amount,
'quota': quota,
'referal_code': referal_code
}
else:
return BaseController.send_error_api({'payload_invalid': True},
'field is not complete')
result = referalservice.update(payloads, id)
if not result['error']:
return BaseController.send_response_api(result['data'],
result['message'])
else:
return BaseController.send_error_api(result['data'],
result['message'])
def update(request, id):
ticket_type = request.form[
'ticket_type'] if 'ticket_type' in request.form else None
price = request.form['price'] if 'price' in request.form else None
information = request.form[
'information'] if 'information' in request.form else ''
type = request.form['type'] if 'type' in request.form else ''
proposal_url = request.files[
'proposal_url'] if 'proposal_url' in request.files else None
usd_price = request.form[
'usd_price'] if 'usd_price' in request.form else None
quota = request.form['quota'] if 'quota' in request.form else None
if ticket_type and price:
payloads = {
'ticket_type': ticket_type,
'price': price,
'information': information,
'type': type,
'proposal_url': proposal_url,
'usd_price': usd_price,
'quota': quota
}
else:
return BaseController.send_error_api(None, 'field is not complete')
result = ticketservice.update(payloads, id)
if not result['error']:
return BaseController.send_response_api(
result['data'], 'ticket succesfully updated')
else:
return BaseController.send_error_api(None, result['data'])
def update(id, request):
name = request.form['name'] if 'name' in request.form else None
email = request.form['email'] if 'email' in request.form else None
phone = request.form['phone'] if 'phone' in request.form else None
note = request.form['note'] if 'note' in request.form else None
type = request.form['type'] if 'type' in request.form else None
stage = request.form['stage'] if 'stage' in request.form else None
attachment = request.files[
'attachment'] if 'attachment' in request.files else None
url = request.form['url'] if 'url' in request.form else None
callback_url = request.form[
'callback_url'] if 'callback_url' in request.form else None
payloads = {
'name': name,
'email': email,
'phone': phone,
'note': note,
'type': type,
'stage': stage,
'attachment': attachment,
'callback_url': callback_url,
'url': url
}
result = sponsorservice.update(id, payloads)
if result['error']:
return BaseController.send_error_api(result['data'],
result['message'])
return BaseController.send_response_api(result['data'],
result['message'])
def checkin(request, user_id):
booth_type = request.json[
'booth_type'] if 'booth_type' in request.json else None
booth_id = request.json[
'booth_id'] if 'booth_id' in request.json else None
speed_dating = request.json[
'speed_dating'] if 'speed_dating' in request.json else False
# booth_type:
# exhibitor -> booth
# sponsor -> sponsor
if booth_type and booth_id:
payloads = {
'booth_type': booth_type,
'booth_id': booth_id,
'speed_dating': speed_dating,
'user_id': user_id
}
else:
return BaseController.send_error_api(None, 'invalid payload')
result = boothcheckinservice.checkin(payloads)
if result['error']:
return BaseController.send_error_api(result['data'],
result['message'])
return BaseController.send_response_api(result['data'],
result['message'])
def delete(id):
result = boothgalleryservice.delete(id)
if result['error']:
return BaseController.send_error_api(result['data'],
result['message'])
return BaseController.send_response_api(result['data'],
result['message'])
def show_payment(payment_id):
payment = paymentservice.show(payment_id)
if payment['error']:
return BaseController.send_error_api(payment['data'],
payment['message'])
return BaseController.send_response_api(payment['data'],
payment['message'])
def show(id):
schedule = scheduleservice.show(id)
if schedule['error']:
return BaseController.send_error_api(schedule['data'],
schedule['message'])
return BaseController.send_response_api(schedule['data'],
schedule['message'])
def show(id):
booth = boothservice.show(id)
if booth['error']:
return BaseController.send_error_api(booth['data'],
booth['message'])
return BaseController.send_response_api(booth['data'],
booth['message'])
def create(request):
name = request.json['name'] if 'name' in request.json else ''
user_id = request.json['user_id'] if 'user_id' in request.json else None
stage_id = request.json[
'stage_id'] if 'stage_id' in request.json else None
points = request.json['points'] if 'points' in request.json else 0
summary = request.json['summary'] if 'summary' in request.json else None
logo_url = request.json[
'logo_url'] if 'logo_url' in request.json else ''
payloads = {
'name': name,
'user_id': user_id,
'stage_id': stage_id,
'points': points,
'summary': summary,
'logo_url': logo_url
}
result = boothservice.create(payloads)
if result['error']:
return BaseController.send_error_api(result['data'],
result['message'])
else:
return BaseController.send_response_api(result['data'],
result['message'])
def index(status):
result = hackatonproposalservice.get(status)
if result['error']:
return BaseController.send_error_api(result['data'],
result['message'])
return BaseController.send_response_api(result['data'],
result['message'])
def create(request):
owner_type = request.json[
'owner_type'] if 'owner_type' in request.json else None
owner_id = request.json[
'owner_id'] if 'owner_id' in request.json else None
discount_amount = request.json[
'discount_amount'] if 'discount_amount' in request.json else 0.1
referal_code = request.json[
'referal_code'] if 'referal_code' in request.json else ''
quota = request.json['quota'] if 'quota' in request.json else 1
if discount_amount and referal_code and quota and owner_type and owner_id:
payloads = {
'owner_type': owner_type,
'owner_id': owner_id,
'discount_amount': discount_amount,
'referal_code': referal_code,
'quota': quota
}
else:
return BaseController.send_error_api({'payload_invalid': True},
'field is not complete')
result = referalservice.create(payloads)
if not result['error']:
return BaseController.send_response_api(result['data'],
result['message'])
else:
return BaseController.send_error_api(result['data'],
result['message'])
def show(id):
notification = notificationservice.show(id)
if notification['error']:
return BaseController.send_error_api(notification['data'],
notification['message'])
return BaseController.send_response_api(notification['data'],
notification['message'])
def create(request, user):
message = request.json['message'] if 'message' in request.json else None
type = request.json['type'] if 'type' in request.json else None
attachment = request.json[
'attachment'] if 'attachment' in request.json else None
receiver = request.json[
'receiver'] if 'receiver' in request.json else None
if message and type:
payloads = {
'message': message,
'type': type,
'attachment': attachment,
'user': user,
'receiver': receiver
}
else:
return BaseController.send_error_api(None, 'field is not complete')
result = notificationservice.create(payloads)
if result['error']:
return BaseController.send_error_api(result['data'],
result['message'])
else:
return BaseController.send_response_api(result['data'],
result['message'])
def update(request, id):
stage_id = request.json[
'stage_id'] if 'stage_id' in request.json else None
event_id = request.json[
'event_id'] if 'event_id' in request.json else None
time_start = request.json[
'time_start'] if 'time_start' in request.json else None
time_end = request.json[
'time_end'] if 'time_end' in request.json else None
if stage_id and event_id and time_start and time_end:
payloads = {
'stage_id': stage_id,
'event_id': event_id,
'time_start': time_start,
'time_end': time_end
}
else:
return BaseController.send_error_api(None, 'field is not complete')
result = scheduleservice.update(payloads, id)
if not result['error']:
return BaseController.send_response_api(
result['data'], 'schedule succesfully updated',
result['included'])
else:
return BaseController.send_error_api(None, result['data'])
def send_certificate():
result = hackatonproposalservice.send_certificate()
if result['error']:
return BaseController.send_error_api(result['data'],
result['message'])
return BaseController.send_response_api(result['data'],
result['message'])
def reward_referal(user):
referal = referalservice.reward_referal(user)
if referal['error']:
return BaseController.send_error_api(referal['data'],
referal['message'])
return BaseController.send_response_api(referal['data'],
referal['message'])
def update(request, user_id=None, booth_id=None):
if user_id is not None:
booth_id = db.session.query(Booth).filter_by(
user_id=user_id).first().as_dict()['id']
name = request.json['name'] if 'name' in request.json else ''
stage_id = request.json[
'stage_id'] if 'stage_id' in request.json else None
stage_id = None if stage_id < 0 else stage_id
points = request.json['points'] if 'points' in request.json else None
summary = request.json['summary'] if 'summary' in request.json else None
if points and summary:
payloads = {
'name': name,
'stage_id': stage_id,
'points': points,
'summary': summary
}
else:
return BaseController.send_error_api(None, 'field is not complete')
result = boothservice.update(payloads, booth_id)
if not result['error']:
return BaseController.send_response_api(result['data'],
result['message'])
else:
return BaseController.send_error_api(result['data'],
result['message'])
def show(id):
beacon = beaconservice.show(id)
if beacon['error']:
return BaseController.send_error_api(beacon['data'],
beacon['message'])
return BaseController.send_response_api(beacon['data'],
beacon['message'])
def get_payments(user_id):
payments = paymentservice.get(user_id)
if (payments['error']):
return BaseController.send_error_api(payments['data'],
payments['message'])
return BaseController.send_response_api(payments['data'],
payments['message'])
def update(request, id):
major = request.json['major'] if 'major' in request.json else None
minor = request.json['minor'] if 'minor' in request.json else None
point = request.json['point'] if 'point' in request.json else None
type = request.json['type'] if 'type' in request.json else None
type_id = request.json['type_id'] if 'type_id' in request.json else None
description = request.json[
'description'] if 'description' in request.json else ''
if major and minor and type and type_id:
payloads = {
'major': major,
'minor': minor,
'point': point,
'type': type,
'type_id': type_id,
'description': description,
}
else:
return BaseController.send_error_api(None, 'invalid payload')
result = beaconservice.update(payloads, id)
if result['error']:
return BaseController.send_error_api(result['data'],
result['message'])
return BaseController.send_response_api(result['data'],
result['message'])
def admin_get_payments():
payments = paymentservice.admin_get()
if (payments['error']):
return BaseController.send_error_api(payments['data'],
payments['message'])
return BaseController.send_response_api(payments['data'],
payments['message'])
def index():
beacons = beaconservice.get()
if beacons['error']:
return BaseController.send_error_api(beacons['data'],
beacons['message'])
return BaseController.send_response_api(beacons['data'],
beacons['message'])
