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 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 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 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 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 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 redeemreferal(self, payloads, id):
response = ResponseBuilder()
user = db.session.query(User).filter_by(id=id)
user_referal = user.first().referal
if user_referal in payloads['referal']:
return response.set_data(None).set_message('dont redeem your own code').set_error(True).build()
user_have_refered = user.first().have_refered
if user_have_refered is 1:
return response.set_data(None).set_message('you cant redeem referal again').set_error(True).build()
referal = db.session.query(User).filter_by(referal=payloads['referal'])
referal_count = referal.first().referal_count
if referal_count is not 10:
referal_count += 1
referal.update({
'referal_count': referal_count
})
user_referal_count = user.first().referal_count
user_referal_count += 1
user.update({
'referal_count': user_referal_count,
'have_refered': 1
})
db.session.commit()
result = db.session.query(User).filter_by(id=id).first()
return response.set_data(result.as_dict()).build()
else:
return response.set_data(None).set_message('this referal code has exceeded its limit').set_error(True).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 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 verify(self, id):
response = ResponseBuilder()
orderverification_query = db.session.query(OrderVerification).filter_by(id=id)
orderverification = orderverification_query.first()
if orderverification.is_used is not 1:
user_query = db.session.query(User).filter_by(id=orderverification.user_id)
user = user_query.first()
items = db.session.query(OrderDetails).filter_by(order_id=orderverification.order_id).all()
if items[0].ticket.type == TICKET_TYPES['exhibitor']:
payload = {}
payload['user_id'] = user.id
payload['ticket_id'] = items[0].ticket_id
UserTicketService().create(payload)
self.create_booth(user)
user_query.update({
'role_id': ROLE['booth']
})
redeem_payload = {}
redeem_payload['ticket_id'] = items[0].ticket_id
redeem_payload['codeable_id'] = user.id
RedeemCodeService().purchase_user_redeems(redeem_payload)
elif items[0].ticket.type == TICKET_TYPES['hackaton']:
payload = {}
payload['user_id'] = user.id
payload['ticket_id'] = items[0].ticket_id
UserTicketService().create(payload)
hackerteam_id = self.create_hackaton(user)
user_query.update({
'role_id': ROLE['hackaton']
})
redeem_payload = {}
redeem_payload['codeable_type'] = TICKET_TYPES['hackaton']
redeem_payload['codeable_id'] = hackerteam_id
redeem_payload['count'] = items[0].ticket.quota
RedeemCodeService().create(redeem_payload)
else:
for item in items:
for i in range(0, item.count):
payload = {}
payload['user_id'] = user.id
payload['ticket_id'] = item.ticket_id
UserTicketService().create(payload)
orderverification_query.update({
'is_used': 1
})
payment_query = db.session.query(Payment).filter_by(order_id=orderverification.order_id)
payment_query.update({
'transaction_status': 'capture'
})
completed_order = db.session.query(Order).filter_by(id=orderverification.order_id)
completed_order.update({
'status': 'paid'
})
db.session.commit()
return response.set_data(None).set_message('ticket purchased').build()
else:
return response.set_data(None).set_message('This payment has already verified').build()
def delete(self, id):
response = ResponseBuilder()
self.model_redeem_code = db.session.query(RedeemCode).filter_by(id=id)
if self.model_redeem_code.first() is not None:
# delete row
self.model_redeem_code.delete()
db.session.commit()
return response.set_data(None).set_message('redeem code delete successfully').set_error(False).build()
else:
return response.set_data(None).set_message('data not found').set_error(True).build()
def delete(self, id):
response = ResponseBuilder()
self.events_model = db.session.query(Event).filter_by(id=id)
if self.events_model.first() is not None:
# delete row
self.events_model.delete()
db.session.commit()
return response.set_data(None).build()
else:
return response.set_data(None).set_error(True).build()
def booth_gallery(self, booth_id):
response = ResponseBuilder()
booth_galleries = 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 retrieved sucessfully').build()
else:
return response.set_data(None).set_message('data not found').set_error(True).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 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()
})
order = orderverification.order
else:
orderverification = OrderVerification()
order_query = db.session.query(Order).filter_by(
id=payload['order_id'])
payment_query = db.session.query(Payment).filter_by(
order_id=payload['order_id'])
order = order_query.first()
orderverification.user_id = order.user_id
orderverification.order_id = payload['order_id']
orderverification.payment_proof = payment_proof
order_query.update({
'status': 'in progress',
'updated_at': datetime.datetime.now()
})
payment_query.update({
'transaction_status': 'in progress',
'updated_at': datetime.datetime.now()
})
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'])
if orderverification:
send_notification = FCMService().send_single_notification(
'Payment Status',
'Payment proof have been uploaded, your payment is being processed',
order.user_id, ROLE['admin'])
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 delete(self, id):
response = ResponseBuilder()
self.model_referal = db.session.query(Referal).filter_by(id=id)
if self.model_referal.first() is not None:
# delete row
self.model_referal.delete()
db.session.commit()
return response.set_data(None).set_message(
'referal deleted successfully').build()
else:
return response.set_data(None).set_error(True).set_message(
'deletion failed').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 password_reset(self, payloads):
response = ResponseBuilder()
user = User().verify_auth_token(payloads['token'])
if user is not None:
self.model_user = db.session.query(User).filter_by(id=user.id)
self.model_user.update({
'password': generate_password_hash(payloads['new_password'])
})
db.session.commit()
return response.set_data(user.as_dict()).set_message('Reset Password success, You can logged in with new password').build()
else:
return response.set_data(None).set_message('Reset Password failed or token expired').build()
def update(self, code, user):
response = ResponseBuilder()
_result = {}
_result['user'] = user
token = db.session.query(AccessToken).filter_by(
user_id=user['id']).first().as_dict()
raw_user = db.session.query(User).filter_by(id=user['id'])
raw_redeem_code = db.session.query(RedeemCode).filter_by(code=code)
if raw_redeem_code.first() is None:
return response.set_data(None).set_error(True).set_message(
'code not found').build()
redeem_code = raw_redeem_code.first().as_dict()
if raw_user.first() is None:
return response.set_data(None).set_error(True).set_message(
'user not found').build()
if redeem_code['used'] == 1:
return response.set_data(None).set_error(True).set_message(
'code already used').build()
try:
if redeem_code['codeable_type'] in ['partner', 'user']:
# become attendee
userticket = UserTicket()
userticket.user_id = user['id']
userticket.ticket_id = 1
db.session.add(userticket)
db.session.commit()
elif redeem_code['codeable_type'] == 'booth':
# get booth of the code
booth = db.session.query(Booth).filter_by(
id=redeem_code['codeable_id']).first().as_dict()
# become member of booth
user_booth = UserBooth()
user_booth.user_id = user['id']
user_booth.booth_id = booth['id']
db.session.add(user_booth)
user['role_id'] = 3
db.session.commit()
_result['user']['booth'] = booth
raw_redeem_code.update({'used': True})
raw_user.update({'role_id': user['role_id']})
db.session.commit()
token_payload = {
'access_token': token['access_token'],
'refresh_token': token['refresh_token']
}
return response.set_data(token_payload).set_included(
_result['user']).set_message('Redeem code updated successfully'
).set_error(False).build()
except SQLAlchemyError as e:
return response.set_data(
e.orig.args).set_message('SQL error').set_error(True).build()
def post_log(self, payload, id):
response = ResponseBuilder()
log = SponsorInteractionLog()
log.description = payload['description']
log.sponsor_id = id
db.session.add(log)
try:
db.session.commit()
return response.set_data(
log.as_dict()).set_message('logged').build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_data(data).set_error(True).build()
def delete(self, id):
response = ResponseBuilder()
self.model_beacon = db.session.query(Beacon).filter(Beacon.id == id)
if self.model_beacon.first() is not None:
# delete row
self.model_beacon.delete()
db.session.commit()
return response.set_data(None).set_message(
'region row deleted succesfully').build()
else:
data = 'data not found'
return response.set_data(data).set_error(True).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 update(self, payloads, id):
response = ResponseBuilder()
try:
self.model_grant_role = db.session.query(User).filter_by(id=id)
self.model_grant_role.update({'role_id': payloads['role_id']})
db.session.commit()
data = self.model_grant_role.first().as_dict()
return response.set_data(data).set_message(
'User updated successfully').set_error(False).build()
except SQLAlchemyError as e:
return response.set_data(
e.orig.args).set_message('SQL error').set_error(True).build()
def add_attendee(self, payloads):
response = ResponseBuilder()
self.attendee = Attendee()
self.attendee.user_id = payloads['user_id']
self.attendee.points = payloads['points']
db.session.add(self.attendee)
try:
db.session.commit()
data = self.attendee.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 add_ambassador(self, payloads):
response = ResponseBuilder()
self.ambassador = Ambassador()
self.ambassador.user_id = payloads['user_id']
self.ambassador.informations = payloads['infrormation']
self.ambassador.institution = payloads['institution']
db.session.add(self.ambassador)
try:
db.session.commit()
data = self.ambassador.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 create(self, payloads):
response = ResponseBuilder()
package_managements = PackageManagement()
package_managements.name = payloads['name']
package_managements.price = payloads['price']
package_managements.quota = payloads['quota']
db.session.add(package_managements)
try:
db.session.commit()
data = package_managements.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 create(self, payloads):
response = ResponseBuilder()
source = Source()
source.account_number = payloads['account_number']
source.bank = payloads['bank']
source.alias = payloads['alias']
db.session.add(source)
try:
db.session.commit()
data = source.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 create(self, payloads):
response = ResponseBuilder()
userfeedback = UserFeedback()
userfeedback.user_id = payloads['user_id']
userfeedback.content = payloads['content']
db.session.add(userfeedback)
try:
db.session.commit()
data = userfeedback.as_dict()
return response.set_data(data).set_message(
'Feedback created').set_error(False).build()
except SQLAlchemyError as e:
data = e.orig.args
return response.set_data(data).set_error(True).set_message(
'Some error occured, please try again later').build()
