def update(self, payloads, booth_id):
response = ResponseBuilder()
try:
self.model_booth = db.session.query(Booth).filter_by(id=booth_id)
self.model_booth.update({
'name': payloads['name'],
'stage_id': payloads['stage_id'],
'points': payloads['points'],
'summary': payloads['summary'],
'url': payloads['url']
})
if payloads['logo']:
photo = self.save_file(payloads['logo'], booth_id)
self.model_booth.update({'logo_url': photo})
db.session.commit()
data = self.model_booth.first().as_dict()
data['user'] = self.model_booth.first().user.include_photos(
).as_dict()
data['stage'] = self.model_booth.first().stage.as_dict(
) if payloads['stage_id'] is not None else None
return response.set_data(data).build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_error(True).set_data(data).set_message(
'sql error').build()
def postIncludes(self, includes):
response = ResponseBuilder()
user_id = self.model_user.as_dict()['id']
entityModel = eval(includes['name'])()
entityModel.user_id = user_id
for key in includes:
if key is not 'name':
setattr(entityModel, key, includes[key])
db.session.add(entityModel)
try:
db.session.commit()
if includes['name'] == 'Booth':
user_booth = UserBooth()
user_booth.user_id = user_id
user_booth.booth_id = entityModel.as_dict()['id']
db.session.add(user_booth)
db.session.commit()
return response.set_data(None).build()
except SQLAlchemyError as e:
data = e.args
return response.set_message(data).set_error(True).set_data(
None).build()
def show(self, id):
# get the booth id
response = ResponseBuilder()
booth = db.session.query(Booth).filter_by(id=id).first()
if booth is None:
data = {'user_exist': True}
return response.set_data(data).set_error(True).set_message(
'booth not found').build()
data = booth.as_dict()
data['user'] = booth.user.include_photos().as_dict()
if data['logo_url']:
data['logo_url'] = Helper().url_helper(
data['logo_url'], current_app.config['GET_DEST'])
user_booth = db.session.query(UserBooth).filter_by(booth_id=id).all()
data['members'] = []
for user in user_booth:
user_id = user.as_dict()['user_id']
user = db.session.query(User).filter_by(id=user_id).first()
data['members'].append(user.include_photos().as_dict())
data['stage'] = booth.stage.as_dict() if booth.stage else None
return response.set_data(data).build()
def create(self, payload):
response = ResponseBuilder()
orderverification_query = db.session.query(OrderVerification).filter_by(order_id=payload['order_id'])
orderverification = orderverification_query.first()
payment_proof = self.save_file(payload['payment_proof']) if payload['payment_proof'] is not None else None
if orderverification:
if orderverification.payment_proof is not None:
Helper().silent_remove(current_app.config['STATIC_DEST'] + orderverification.payment_proof)
orderverification_query.update({
'payment_proof': payment_proof,
'updated_at': datetime.datetime.now()
})
else:
orderverification = OrderVerification()
order = db.session.query(Order).filter_by(id=payload['order_id']).first()
orderverification.user_id = order.user_id
orderverification.order_id = payload['order_id']
orderverification.payment_proof = payment_proof
db.session.add(orderverification)
try:
db.session.commit()
result = orderverification.as_dict()
result['payment_proof'] = Helper().url_helper(result['payment_proof'], current_app.config['GET_DEST'])
return response.set_data(result).set_message('Data created succesfully').build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_data(data).set_error(True).build()
def update(self, id, payload):
response = ResponseBuilder()
orderverification = db.session.query(OrderVerification).filter_by(
id=id)
data = orderverification.first().as_dict() if orderverification.first(
) else None
if data['payment_proof'] is not None and payload['payment_proof']:
Helper().silent_remove(current_app.config['STATIC_DEST'] +
data['payment_proof'])
if data is None:
return response.set_error(True).set_message(
'data not found').set_data(None).build()
payment_proof = self.save_file(
payload['payment_proof']
) if payload['payment_proof'] is not None else None
try:
orderverification = db.session.query(OrderVerification).filter_by(
id=id)
orderverification.update({
'user_id': payload['user_id'],
'order_id': payload['order_id'],
'payment_proof': payment_proof,
'updated_at': datetime.datetime.now()
})
db.session.commit()
data = orderverification.first()
return response.set_data(data.as_dict()).build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_error(True).set_data(data).build()
def resend_certificate(self, payloads):
response = ResponseBuilder()
emailservice = EmailService()
mail_template = EmailHackaton("devsummit-hackathon-certificate.html")
checked_in = db.session.query(UserTicket.user_id).join(CheckIn).all()
checkins = [i[0] for i in checked_in]
print(checkins)
user = db.session.query(User).filter(
or_(User.id == payloads['user_id'],
User.email == payloads['user_id'])).first()
if user is None:
return response.set_data(None).set_message(
'user not found.').set_error(True).build()
if user.id not in checkins:
return response.set_data(None).set_message(
'user found but did not check in.').set_error(True).build()
extra = "<br/><br/><br/>Link to your downloadable certificate: <a href='https://api.devsummit.io/certificate-%s.pdf'>here</a>" % user.id
template = mail_template.build(user.first_name + ' ' + user.last_name,
extra)
email = emailservice.set_recipient(user.email).set_subject(
'Indonesia Developer Summit 2017').set_sender(
'*****@*****.**').set_html(template).build()
mail.send(email)
return response.set_data(None).set_message('email has been sent to: ' +
user.email).build()
def add_booth(self, payloads):
response = ResponseBuilder()
booth_exists = db.session.query(
db.exists().where(Booth.user_id == payloads['user_id'])).scalar()
if booth_exists:
return response.set_data(payloads).build()
self.booth = Booth()
self.booth.name = payloads['booth_name']
self.booth.user_id = payloads['user_id']
self.booth.stage_id = payloads['stage_id']
self.booth.points = payloads['points']
self.booth.summary = payloads['summary']
db.session.add(self.booth)
try:
db.session.commit()
data = self.booth.as_dict()
user_booth = UserBooth()
user_booth.user_id = data['user_id']
user_booth.booth_id = data['id']
db.session.add(user_booth)
db.session.commit()
return response.set_data(data).build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_data(data).set_error(True).build()
def get_attendees(self):
response = ResponseBuilder()
_results = []
attendees = db.session.query(User).filter(User.role_id == 7).all()
for attendee in attendees:
_results.append(attendee.include_photos().as_dict())
return response.set_data(_results).set_message('Attendees retrieved successfully').build()
def create(self, payloads):
response = ResponseBuilder()
feed = Feed()
sponsor = db.session.query(Sponsor).filter_by(
id=payloads['sponsor_id']).first()
attachment = self.save_file(
payloads['attachment']
) if payloads['attachment'] is not None else None
feed.message = payloads['message']
feed.attachment = attachment
feed.user_id = payloads['user_id']
feed.type = payloads['type']
feed.redirect_url = payloads['redirect_url']
feed.sponsor_id = payloads['sponsor_id']
db.session.add(feed)
try:
db.session.commit()
user = feed.user.include_photos().as_dict()
del user['fcmtoken']
data = feed.as_dict()
data['attachment'] = Helper().url_helper(
data['attachment'], current_app.config['GET_DEST']
) if data['attachment'] is not None else None
if 'user' in payloads['type']:
data['user'] = user
elif 'sponsor' in payloads['type']:
data['user'] = sponsor.as_dict()
return response.set_data(data).build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_data(data).set_error(True).build()
def shows(self, user, speaker_id):
response = ResponseBuilder()
speaker = db.session.query(Speaker).filter_by(id=speaker_id).first()
if user['role_id'] is ROLE['user']:
speaker_document = db.session.query(SpeakerDocument).filter_by(
speaker_id=speaker_id,
is_used=1).order_by(SpeakerDocument.created_at.desc()).all()
elif user['role_id'] is ROLE['speaker']:
speaker_document = db.session.query(SpeakerDocument).filter_by(
speaker_id=speaker_id).order_by(
SpeakerDocument.created_at.desc()).all()
_results = []
if speaker_document is not None:
speaker_document = BaseModel.as_list(speaker_document)
for _speaker_document in speaker_document:
_speaker_document['material'] = Helper().url_helper(
_speaker_document['material'],
app.config['GET_SPEAKER_DOC_DEST'])
_speaker_document['user'] = speaker.user.include_photos(
).as_dict()
_results.append(_speaker_document)
return response.set_data(_results).build()
else:
data = 'data not found'
return response.set_data(None).set_message(data).build()
def list_hackaton_attendee(self):
response = ResponseBuilder()
_results = []
hackers = db.session.query(User).filter(User.role_id==ROLE['hackaton']).all()
for hacker in hackers:
_results.append(hacker.include_photos().as_dict())
return response.set_data(_results).set_message('hackers retreived').set_links({}).build()
def create(self, payloads):
response = ResponseBuilder()
speaker_id = payloads['speaker_id']
speaker = db.session.query(Speaker).filter_by(
id=speaker_id).first().as_dict()
file = payloads['document_data']
title = payloads['title']
summary = payloads['summary']
is_used = int(payloads['is_used'])
if file and Helper().allowed_file(
file.filename, app.config['ALLOWED_SPEAKER_DOC_EXTENSIONS']):
self.model_speaker_document = SpeakerDocument()
db.session.add(self.model_speaker_document)
try:
file_name = Helper().time_string() + "_" + file.filename
file.save(
os.path.join(app.config['POST_SPEAKER_DOC_DEST'],
file_name))
self.model_speaker_document.material = app.config[
'SAVE_SPEAKER_DOC_DEST'] + file_name
self.model_speaker_document.speaker_id = speaker_id
self.model_speaker_document.summary = summary
self.model_speaker_document.title = title
self.model_speaker_document.is_used = is_used
db.session.commit()
data = self.model_speaker_document.as_dict()
data['material'] = Helper().url_helper(
self.model_speaker_document.material,
app.config['GET_SPEAKER_DOC_DEST'])
data['user'] = db.session.query(User).filter_by(
id=speaker['user_id']).first().include_photos().as_dict()
return response.set_data(data).build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_error(True).set_message(data).build()
def update_photo(self, payloads, id):
response = ResponseBuilder()
try:
user_photo = db.session.query(UserPhoto).filter_by(user_id=id)
file = payloads['photo']
photo = None
photo = self.save_file(file, id)
if user_photo.first() is None:
user_photo = UserPhoto()
user_photo.user_id = id
user_photo.url = photo
db.session.add(user_photo)
db.session.commit()
return response.set_message('Photo updated').set_data(None).build()
if photo:
user_photo.update({
'url': photo,
'updated_at': datetime.datetime.now()
})
db.session.commit()
data = user_photo.first().as_dict()
return response.set_data(data).build()
except SQLAlchemyError as e:
data = e
return response.set_error(True).set_data(data).build()
def checkin_list(self, request, page):
self.total_items = CheckIn.query.count()
if page is not None:
self.page = request.args.get('page')
# self.page = page
else:
self.perpage = 10
self.page = 1
self.base_url = request.base_url
# paginate
checkins = super().paginate(
db.session.query(CheckIn).order_by(CheckIn.updated_at.desc()))
response = ResponseBuilder()
# checkins = db.session.query(CheckIn).all()
_results = []
# if checkins is not None:
for checkin in checkins['data']:
data = checkin.as_dict()
data = self.transformTimeZone(data)
user_ticket = db.session.query(UserTicket).filter_by(
id=checkin.user_ticket_id).first()
data['user_tickets'] = user_ticket.as_dict()
data['user_tickets']['user'] = db.session.query(User).filter_by(
id=user_ticket.user_id).first().as_dict()
_results.append(data)
return response.set_data(_results).set_links(checkins['links']).build()
def transfer_points(self, receiver_id, sender_id, points):
response = ResponseBuilder()
# query users
booth = db.session.query(Booth).filter_by(user_id=sender_id).first()
user = db.session.query(User).filter_by(id=receiver_id).first()
# check booth points first
if booth.points < points:
return response.set_error(True).set_data(
'You don\'t have enough point to grant').build()
# transfer point
booth.points = booth.points - points
if user.points:
user.points = user.points + points
else:
user.points = points
try:
db.session.commit()
# log transfer
transaction_log = PointTransactionLog()
transaction_log.booth_id = booth.id
transaction_log.user_id = user.id
transaction_log.amount = points
db.session.add(transaction_log)
db.session.commit()
# return value
return response.set_data('Point transfered succesfully').build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_data(data).set_error(True).build()
def create(self, payload):
response = ResponseBuilder()
invoice = Invoice()
invoice.payload = payload[
'description'] if 'description' in payload else ''
invoice.total = payload['total'] if 'total' in payload else None
invoice.address = payload['address'] if 'address' in payload else ''
invoice.description = payload[
'description'] if 'description' in payload else ''
invoice.invoiceable_type = payload[
'invoiceable_type'] if 'invoiceable_type' in payload else ''
invoice.invoiceable_id = payload[
'invoiceable_id'] if 'invoiceable_id' in payload else ''
if invoice.total is None:
return response.set_data(None).set_error(True).build()
else:
db.session.add(invoice)
try:
db.session.commit()
return response.set_data(
invoice.as_dict()).set_message('invoice created').build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_data(None).set_message(data).set_error(
True).build()
def update(self, id, payloads):
response = ResponseBuilder()
if payloads['attachment'] is not None:
prizelist_dict = db.session.query(PrizeList).filter_by(
id=id).first()
if prizelist_dict.attachment is not None:
os.remove(current_app.config['STATIC_DEST'] +
prizelist_dict.attachment)
attachment = self.save_file(
payloads['attachment']
) if payloads['attachment'] is not None else None
try:
prizelist = db.session.query(PrizeList).filter_by(id=id)
prizelist.update({
'name': payloads['name'],
'point_cost': payloads['point_cost'],
'attachment': attachment,
'count': payloads['count'],
'updated_at': datetime.datetime.now()
})
db.session.commit()
data = prizelist.first()
return response.set_data(data.as_dict()).build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_error(True).set_data(data).build()
def cstore(self, payloads):
response = ResponseBuilder()
if not all(
isinstance(string, str) for string in [
payloads['order_id'],
payloads['first_name'],
payloads['last_name'],
payloads['email'],
payloads['phone'],
]) and not isinstance(payloads['gross_amount'], int):
return response.build_invalid_payload_response()
# get referral by order id
ref = self.get_order_referal(payloads['order_id'])
details = self.get_order_details(payloads['order_id'], ref)
data = {}
data['payment_type'] = payloads['payment_type']
data['transaction_details'] = {}
data['transaction_details']['gross_amount'] = payloads['gross_amount']
data['transaction_details']['order_id'] = payloads['order_id']
data['cstore'] = {}
data['cstore']['store'] = 'Indomaret'
data['cstore']['message'] = 'dev summit ticket transaction'
data['customer_details'] = {}
data['customer_details']['first_name'] = payloads['first_name']
data['customer_details']['last_name'] = payloads['last_name']
data['customer_details']['email'] = payloads['email']
data['customer_details']['phone'] = payloads['phone']
data['details'] = details
return self.send_to_midtrans_api(data)
def change_name(self, payloads):
response = ResponseBuilder()
try:
self.model_user = db.session.query(
User).filter_by(id=payloads['user']['id'])
self.model_user.update({
'first_name': payloads['first_name'],
'last_name': payloads['last_name'],
'updated_at': datetime.datetime.now()
})
db.session.commit()
data = self.model_user.first().include_photos().as_dict()
if (data['role_id'] is ROLE['booth']):
booth = db.session.query(Booth).filter_by(user_id=payloads['user']['id'])
if payloads['booth_info'] is not None:
booth.update({
'summary': payloads['booth_info']
})
db.session.commit()
data['booth'] = booth.first().as_dict()
elif data['role_id'] is ROLE['speaker']:
speaker = db.session.query(Speaker).filter_by(user_id=payloads['user']['id'])
if payloads['speaker_job'] is not None and payloads['speaker_summary'] is not None:
speaker.update({
'job': payloads['speaker_job'],
'summary': payloads['speaker_summary']
})
db.session.commit()
data['speaker'] = speaker.first().as_dict()
return response.set_data(data).build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_error(True).set_message(data).build()
def admin_get(self, request):
# TODO: optimize this method
report_feeds = db.session.query(FeedReport).group_by(FeedReport.feed_id).all()
results = []
for feed in report_feeds:
if feed.feed.deleted_at is not None:
continue
spam = db.session.query(FeedReport).filter(FeedReport.feed_id == feed.feed_id).filter(FeedReport.report_type == 'spam').count()
racism = db.session.query(FeedReport).filter(FeedReport.feed_id == feed.feed_id).filter(FeedReport.report_type == 'racism').count()
pornography = db.session.query(FeedReport).filter(FeedReport.feed_id == feed.feed_id).filter(FeedReport.report_type == 'pornography').count()
violence = db.session.query(FeedReport).filter(FeedReport.feed_id == feed.feed_id).filter(FeedReport.report_type == 'violence').count()
data = {
'feed_id': feed.feed_id,
'message': feed.feed.message,
'username': feed.feed.user.username,
'report_type': {
'Racism': racism,
'Spam': spam,
'Pornography': pornography,
'Violence': violence
}
}
results.append(data)
response = ResponseBuilder()
result = response.set_data(results).build()
return result
def filter(self, param):
schedules = self.get()['data']
results = []
day1 = []
day2 = []
day3 = []
for schedule in schedules:
if schedule['event'] is not None and EVENT_DATES['1'] in schedule[
'time_start']:
day1.append(schedule)
elif schedule['event'] is not None and EVENT_DATES[
'2'] in schedule['time_start']:
day2.append(schedule)
elif schedule['event'] is not None and EVENT_DATES[
'3'] in schedule['time_start']:
day3.append(schedule)
response = ResponseBuilder()
if param == 'day-1':
results = day1
elif param == 'day-2':
results = day2
elif param == 'day-3':
results = day3
else:
results.append(day1)
results.append(day2)
results.append(day3)
result = response.set_data(results).build()
return result
def update(self, payloads, entrycashlog_id):
response = ResponseBuilder()
if not isinstance(payloads['debit'], int) and not isinstance(
payloads['credit'], int) and not isinstance(
payloads['description'], str):
return response.set_error(True).set_status_code(400).set_message(
'payloads is invalid').build()
try:
self.model_entrycashlog = db.session.query(EntryCashLog).filter_by(
id=entrycashlog_id)
self.model_entrycashlog.update({
'debit':
payloads['debit'],
'credit':
payloads['credit'],
'source_id':
payloads['source_id'],
'description':
payloads['description']
})
db.session.commit()
data = self.model_entrycashlog.first().as_dict()
return {'error': False, 'data': data}
except SQLAlchemyError as e:
data = e.orig.args
return {'error': True, 'data': data}
def show(self, id):
response = ResponseBuilder()
feed_report = db.session.query(FeedReport).filter_by(id=id).first()
data = {}
data = feed_report.as_dict() if feed_report else None
data['user'] = feed_report.user.include_photos().as_dict()
return response.set_data(data).build()
def create(self, payloads):
response = ResponseBuilder()
booth_id = payloads['booth_id']
files = payloads['image_files']
check = self.check_files(files)
if not check:
return response.set_error(True).set_message('one or more files are not in correct format').build()
else:
results = []
for file in files:
self.model_booth_gallery = BoothGallery()
db.session.add(self.model_booth_gallery)
success = True
try:
file_name = Helper.time_string() + "_" + file.filename
file.save(os.path.join(current_app.config['POST_BOOTH_GALL_DEST'], file_name))
self.model_booth_gallery.url = current_app.config['SAVE_BOOTH_GALL_DEST'] + file_name
self.model_booth_gallery.booth_id = booth_id
db.session.commit()
data = self.model_booth_gallery.as_dict()
data['url'] = Helper().url_helper(data['url'], current_app.config['GET_DEST'])
results.append(data)
except:
success = False
if success:
return response.set_data(results).set_message('upload success').build()
else:
return response.set_error(True).set_message('some files can not be uploaded').set_data(None).build()
def update(self, payloads, id):
response = ResponseBuilder()
try:
partner = db.session.query(Partner).filter_by(id=id)
file = payloads['photo']
photo = None
photo = self.save_file(file, id)
partner.update({
'name': payloads['name'],
'email': payloads['email'],
'website': payloads['website'],
'type': payloads['type'],
'updated_at': datetime.datetime.now()
})
if photo:
partner.update({
'photo': photo,
'updated_at': datetime.datetime.now()
})
db.session.commit()
data = partner.first().as_dict()
return response.set_data(data).build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_error(True).set_data(data).build()
def update(self, id):
response = ResponseBuilder()
# get the transaction id from payment table
payment = db.session.query(Payment).filter_by(id=id).first()
if payment is not None:
order = payment.order.as_dict()
payment = payment.as_dict()
else:
return response.set_error(True).set_message('payment not found').build()
payment_status = requests.get(
url + str(payment['order_id']) + '/status',
headers=self.headers
)
status = payment_status.json()
if status['status_code'] in ['200', '201', '407', '412']:
if (payment['transaction_status'] != status['transaction_status']):
payment = db.session.query(Payment).filter_by(id=id)
payment.update({
'updated_at': datetime.datetime.now(),
'transaction_status': status['transaction_status']
})
db.session.commit()
if (payment.first().as_dict()['transaction_status'] == 'expire'):
# on payment success
self.save_paid_ticket(order)
return response.set_data(status).build()
return response.build_invalid_payload_response()
def get(self):
response = ResponseBuilder()
beacons = db.session.query(Beacon).all()
_results = []
for beacon in beacons:
_results.append(beacon.as_dict())
return response.set_data(_results).set_message(
'region retrieved succesfully').build()
def show(self, id):
response = ResponseBuilder()
prizelist = db.session.query(PrizeList).filter_by(id=id).first()
data = prizelist.as_dict() if prizelist else None
if data:
return response.set_data(data).build()
return response.set_error(True).set_message('data not found').set_data(
None).build()
def show(self, id):
response = ResponseBuilder()
beacon = db.session.query(Beacon).filter(Beacon.id == id).first()
if beacon:
return response.set_data(beacon.as_dict()).set_message(
'beacon retrieved succesfully').build()
return response.set_data(None).set_error(True).set_message(
'beacon not found').build()
def admin_filter(self, param): response = ResponseBuilder() results = self.admin_get()['data'] _results = [] for result in results: if result['fraud_status'] is not None and result['fraud_status'] == param['fraud_status']: _results.append(result) return response.set_data(_results).build()
