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 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 show(self, id, user):
response = ResponseBuilder()
result = db.session.query(UserFeedback).filter_by(id=id).first()
if result is not None:
if result.user_id == user['id'] or result.user_id == ROLE['admin']:
result = result.as_dict()
return response.set_data(result).set_error(False).set_message(
'user feedback retrieved successfully').build()
else:
return response.set_error(True).set_message(
'user is not authorized').build()
else:
return response.set_error(True).set_data(None).set_message(
'row not found').build()
def transfer(self, user_id, user_ticket_id, receiver):
response = ResponseBuilder()
userticket = db.session.query(UserTicket).filter_by(id=user_ticket_id)
if userticket.first() is None:
return response.set_error(True).set_data(None).set_message(
'ticket not found').build()
if userticket.first().as_dict()['user_id'] != user_id:
return response.set_error(True).set_data(None).set_message(
'this ticket is not yours').build()
receiver_raw = db.session.query(User).filter(
or_(User.username.like(receiver),
User.email.like(receiver))).first()
if receiver_raw is None:
return response.set_error(True).set_data(None).set_message(
'receiver could not be found').build()
receiver_id = receiver_raw.as_dict()['id']
try:
# update user ticket
userticket.update({
'user_id': receiver_id,
'updated_at': datetime.datetime.now()
})
db.session.commit()
# add transfer log
transferlog = TicketTransferLog()
transferlog.sender_user_id = user_id
transferlog.receiver_user_id = receiver_id
# transferlog.user_ticket_id = 1
transferlog.user_ticket_id = user_ticket_id
db.session.add(transferlog)
db.session.commit()
data = transferlog.as_dict()
for key in data.keys():
if key in ['receiver', 'sender']:
temp_dict = data[key].as_dict()
data[key] = temp_dict
return response.set_data(data).set_message(
'ticket transfered successfully').build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_data(None).set_message(data).set_error(
True).build()
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 reward_point(self, payloads, user):
response = ResponseBuilder()
beacon = db.session.query(Beacon).filter(
Beacon.major == payloads['major'],
Beacon.minor == payloads['minor']).first()
if beacon is None:
return response.set_data(None).set_message(
'beacon not found').set_error(True).build()
if beacon.point is None:
return response.set_data(None).set_message(
'no point assigned to this beacon').set_error(True).build()
user_query = db.session.query(User).filter(User.id == user.id)
curr_point = user.points if user.points else 0
user_query.update({
'points': curr_point + beacon.point,
'updated_at': datetime.datetime.now()
})
try:
db.session.commit()
return response.set_data({
'points': user.points,
'rewarded': beacon.point
}).set_message('point gained').build()
except SQLAlchemyError as e:
return response.set_error(True).set_data(None).set_message(
'sql_error').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 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 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, 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(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 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 bannedfeeds(self, feed_id):
response = ResponseBuilder()
self.model_feed = db.session.query(Feed).filter_by(id=feed_id)
if self.model_feed.first() is None:
return response.set_error(True).set_message(
'feed not found').build()
if self.model_feed.first().deleted_at is not None:
return response.set_error(True).set_message(
'feed already banned').build()
self.model_feed.update({'deleted_at': datetime.datetime.now()})
try:
db.session.commit()
return response.set_data(None).set_message('Success').build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_data(data).set_error(True).build()
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 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 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 delete(self, user, id):
response = ResponseBuilder()
feed = db.session.query(Feed).filter_by(id=id)
if feed.first() is None:
return response.set_error(True).set_data(None).set_message('feed not found').build()
if user['role_id'] != ROLE['admin']:
if feed.first().as_dict()['user_id'] != user['id']:
print(feed.first().as_dict())
return response.set_error(True).set_data(None).set_message('you are unauthorized to delete this feed').build()
feed.delete()
try:
db.session.commit()
return response.set_data(None).set_message('Feed deleted').build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_data(data).set_error(True).build()
def register(self, payloads):
user_refcount = 0
user_havref = 0
response = ResponseBuilder()
# payloads validation
if payloads is None:
return response.set_error(True).set_message('Payload not valid').build()
# check if social or email
if payloads['social_id'] is not None:
check_user = db.session.query(User).filter_by(
social_id=payloads['social_id']).first()
else:
check_user = db.session.query(User).filter_by(
email=payloads['email']).first()
# check if user already exist
if(check_user is not None):
return response.set_data(None).set_message('User already registered').set_error(True).build()
if payloads['email'] is not None:
try:
self.model_user = User()
self.model_user.first_name = payloads['first_name']
self.model_user.last_name = payloads['last_name']
self.model_user.email = payloads['email']
self.model_user.username = payloads['username']
self.model_user.role_id = payloads['role']
self.model_user.social_id = payloads['social_id']
self.model_user.referer = payloads['referer']
self.model_user.referal = self.generate_referal_code(3)
self.model_user.referal_count = user_refcount
self.model_user.have_refered = user_havref
if payloads['provider'] == 'email':
self.model_user.hash_password(payloads['password'])
db.session.add(self.model_user)
db.session.commit()
data = self.model_user
# invoke send confirmation email method here
self.send_confirmation_email(data)
return data
except SQLAlchemyError as e:
data = e.orig.args
return response.set_error(True).set_message('SQL error').set_data(data).build()
def get_user_info(self, user):
response = ResponseBuilder()
access_token = db.session.query(AccessToken).filter_by(
user_id=user.id).first()
if access_token is None:
return response.set_error(True).set_data(None).set_message(
'user is not logged in').build()
return access_token.as_dict(), access_token.user.include_photos(
).as_dict()
def show(self, id):
response = ResponseBuilder()
packagemanagement = db.session.query(PackageManagement).filter_by(
id=id).first()
data = packagemanagement.as_dict() if packagemanagement 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 broadcast_notification(self, title, message, sender_id):
response = ResponseBuilder()
if not self.save_notification(title, message, None, sender_id):
return response.set_error(True).set_message(
'failed to save notification').set_data(None).build()
result = self.broadcast_message(title, message)
if 'message_id' in result.json():
return response.set_data(
result.json()).set_message('notification broadcasted').build()
return response.set_data(None).set_message(
'an error occured').set_error(True).build()
def self_gallery(self, booth_id):
response = ResponseBuilder()
booth_galleries = BaseModel.as_list(db.session.query(BoothGallery).filter_by(booth_id=booth_id).all())
if booth_galleries is not None:
for booth_gallery in booth_galleries:
booth_gallery = booth_gallery
booth_gallery['url'] = Helper().url_helper(booth_gallery['url'], current_app.config['GET_DEST'])
return response.set_data(booth_galleries).set_message('data retieved successfully').build()
else:
return response.set_error(True).set_data(None).set_message('data not found').build()
def show(self, id):
response = ResponseBuilder()
orderverification = db.session.query(OrderVerification).filter_by(order_id=id).first()
data = orderverification.as_dict() if orderverification else None
if data:
if data['payment_proof']:
data['payment_proof'] = Helper().url_helper(data['payment_proof'], current_app.config['GET_DEST'])
else:
data['payment_proof'] = ""
return response.set_data(data).build()
return response.set_error(True).set_message('data not found').set_data(None).build()
def updatefcmtoken(self, token, user):
response = ResponseBuilder()
user = db.session.query(User).filter_by(id=user['id'])
user.update({'fcmtoken': token})
try:
db.session.commit()
return response.set_data(
user.first().include_photos().as_dict()).build()
except SQLAlchemyError as e:
data = e.args
return response.set_error(True).set_message(data).build()
def send_to_midtrans_api(self, payloads):
response = ResponseBuilder()
endpoint = url + 'charge'
result = requests.post(
endpoint,
headers=self.headers,
json=payloads
)
payload = result.json()
if(str(payload['status_code']) in ['400', '202']):
if 'validation_messages' in payload and payload['validation_messages'][0]:
messages = payload['validation_messages'][0]
elif 'status_message' in payload:
messages = payload['status_message']
else:
messages = 'unknown error occured'
return response.set_error(True).set_status_code(payload['status_code']).set_message(messages).build()
else:
if 'bank' in payloads and payloads['payment_type'] != 'credit_card':
payload['bank'] = payloads['bank']
elif payloads['payment_type'] == 'echannel':
payload['bank'] = 'mandiri_bill'
payload['va_number'] = self.get_midtrans_va_number(payload)
else:
if 'bank_transfer' in payloads:
payload['bank'] = payloads['bank_transfer']['bank']
payload['va_number'] = self.get_midtrans_va_number(payload)
else:
payload['bank'] = None
if payloads['payment_type'] in ['bca_klikbca', 'bca_klikpay', 'cimb_clicks', 'danamon_online', 'bri_epay']:
payload['va_number'] = payload['redirect_url']
if 'status_code' in payload and payload['status_code'] == '406':
return response.set_data(payload).set_error(True).set_message('Duplicate order ID. Order ID has already been utilized previously').build()
# handle indomaret payment
if payloads['payment_type'] == 'cstore':
payload['bank'] = 'indomaret'
payload['fraud_status'] = payload['payment_code']
if ('status_code' in payload and str(payload['status_code']) in ['201', '200']):
self.save_payload(payload, payloads)
# if not fraud and captured save ticket to user_ticket table
if('fraud_status' in payload and payload['fraud_status'] == 'accept' and payload['transaction_status'] == 'capture'):
order = db.session.query(Order).filter_by(id=payload['order_id']).first()
self.save_paid_ticket(order.as_dict())
message = payload['status_message'] if 'status_message' in payload else 'No message from payload'
return response.set_data(payload).set_message(message).build()
def generate_room(self, id):
response = ResponseBuilder()
channel_id = None
booth, user = db.session.query(
Booth, User).join(User).filter(Booth.id == id).first()
name = booth.name if booth.name is not None else 'Booth Chatroom'
logo = booth.logo_url
email = self.qiscus_register(user, booth)
endpoint = QISCUS['BASE_URL'] + 'create_room'
payloads = {
'name': name,
'participants': [email],
'creator': email,
'avatar_url': logo
}
result = requests.post(endpoint, headers=self.headers, json=payloads)
payload = result.json()
if 'error' not in payload:
channel_id = payload['results']['room_id_str']
else:
return response.set_error(True).set_data(
payload['error']).set_message('qiscus service error').build()
try:
self.model_booth = db.session.query(Booth).filter_by(id=id)
self.model_booth.update({
'channel_id': channel_id,
})
db.session.commit()
data = self.model_booth.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).set_message(
'sql error').build()
def send_single_notification(self, title, message, uid, sender_id):
response = ResponseBuilder()
user = db.session.query(User).filter_by(id=uid).first().as_dict()
if not self.save_notification(title, message, uid, sender_id):
return response.set_error(True).set_message(
'failed to save notification').set_data(None).build()
fcmtoken = user['fcmtoken']
if fcmtoken is not None:
result = self.send_message(fcmtoken, title, message)
if 'success' in result.json() and result.json()['success'] == 1:
return response.set_data(
result.json()).set_message('notification sent').build()
return response.set_data(None).set_message('notification sent').build()
def show(self, id):
response = ResponseBuilder()
sponsor = db.session.query(Sponsor).filter_by(id=id).first()
data = sponsor.as_dict() if sponsor else None
if data:
if data['attachment']:
data['attachment'] = Helper().url_helper(
data['attachment'], current_app.config['GET_DEST'])
else:
data[
'attachment'] = "https://museum.wales/media/40374/thumb_480/empty-profile-grey.jpg"
return response.set_data(data).build()
return response.set_error(True).set_message('data not found').set_data(
None).build()
def update_team_logo(self, payloads, id):
response = ResponseBuilder()
logo = self.save_file(
payloads['logo']) if payloads['logo'] is not None else None
try:
hackatonteam = db.session.query(HackerTeam).filter_by(id=id)
hackatonteam.update({'logo': logo})
db.session.commit()
data = hackatonteam.first().as_dict()
return response.set_data(data).set_message(
'Update logo team success').build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_error(True).set_data(data).set_message(
'Update Failed').build()
def show(self, id):
response = ResponseBuilder()
invoice = db.session.query(Invoice).filter_by(id=id).first()
included = None
if invoice is None:
return response.set_error(True).set_data(None).set_message(
'invoice not found').build()
if (invoice.invoiceable_type == 'partners'):
# include partner data here.
partner = db.session.query(Partner).filter_by(
id=invoice.invoiceable_id).first()
if partner is not None:
included = partner.as_dict()
return response.set_data(invoice.as_dict()).set_included(
included).set_message('invoice retrieved succesfully').build()
