def on_patch(self, req, resp, login_id, session):
#Authenticate login id and session availability.
try:
if (MemcacheFunctions.IsSessionValid(login_id, session) is False):
resp.status = falcon.HTTP_401
Error = {"Reason": "Invalid Login Credentials or Session is Expired"}
result_json = json.dumps(Error)
resp.body = result_json
return
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400, traceback.print_exc(file=sys.stdout) , err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400, 'Error', err.args)
try :
# Reading Json
raw_json = req.stream.read(req.content_length or 0).decode('utf-8')
resultdict_json = json.loads(raw_json, object_pairs_hook=OrderedDict, encoding='utf-8')
# Json value
quotation_id = resultdict_json['quotation_id']
old_status = resultdict_json['current_quotation_status']
desired_status = resultdict_json['quotation_status']
# Connecting the database
database_connection = get_db_connection()
cursor = database_connection.cursor()
# Check the quotation status
cursor.execute("select q.quotation_status, l.official_email\
from ship_quotations q\
join logistic_providers l on q.supplier_login_id = l.login_id\
where q.quotation_id = '"+quotation_id+"'")
row = cursor.fetchone()
if (cursor.rowcount > 0):
book_status_dict = Tools.QuotationStatus(desired_status,old_status)
print(book_status_dict)
book_status_list = book_status_dict['current_quotation_status']
if(old_status in book_status_list):
index_code = book_status_list.index(old_status)
Tools.ChangeQuotationStatus(quotation_id, desired_status,cursor,database_connection)
resp.status = falcon.HTTP_200
resp.body = ("200")
if(desired_status == 'CLOSED'):
EmailTools.QTClosedEmailNotify(row['official_email'],quotation_id,10)
else:
resp.status = falcon.HTTP_202
resp.body = ("202")
else:
resp.status = falcon.HTTP_204
resp.body = ("204")
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400, traceback.print_exc(file=sys.stdout) , err.args)
except pymysql.IntegrityError as err:
raise falcon.HTTPError(falcon.HTTP_400, traceback.print_exc(file=sys.stdout) , err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400, traceback.print_exc(file=sys.stdout) , err.args)
finally:
cursor.close()
database_connection.close()
def on_post(self, req, resp):
try:
# Reading Json
raw_json = req.stream.read(req.content_length or 0).decode('utf-8')
resultdict_json = json.loads(raw_json, object_pairs_hook=OrderedDict, encoding='utf-8')
# Converting Json to List
list_values = [v for v in resultdict_json.values()]
# Database Connection
database_connection =get_db_connection()
cursor = database_connection.cursor()
# Accessing Temporary password function from Tools
tempPassword = Tools.TemporaryPassword(size = 8, chars = string.ascii_uppercase + string.digits)
# Accessing GenerateTokenId from Tools
tokenID = Tools.GenerateTokenId()
EmailTools.ActivationEmail(list_values[5],"Intuglo Account Activation",list_values[0],tokenID)
status_signup = Tools.SignupUser(resultdict_json['Name'], resultdict_json['PhoneNumber'], resultdict_json['Country'], resultdict_json['Business'], resultdict_json['Industry'],resultdict_json['Email'],resultdict_json['UserType'],2,tokenID,tempPassword,cursor,database_connection)
if(status_signup is True):
resp.status = falcon.HTTP_200
message = {'Status': 'Your account is successfully created'}
result_json = json.dumps(message,default=str)
resp.body = result_json
else:
resp.status = falcon.HTTP_400
message = {'Status': 'Email existed. Try login with another email'}
result_json = json.dumps(message)
resp.body = result_json
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400, traceback.print_exc(file=sys.stdout) , err.args)
except pymysql.IntegrityError as err:
raise falcon.HTTPError(falcon.HTTP_400, traceback.print_exc(file=sys.stdout) , err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400, traceback.print_exc(file=sys.stdout) , err.args)
finally:
cursor.close()
database_connection.close()
def on_patch(self, req, resp):
try:
raw_json = req.stream.read(req.content_length or 0).decode('utf-8')
result_dictionary_json = json.loads(raw_json,
object_pairs_hook=OrderedDict,
encoding='utf-8')
list_values = [v for v in result_dictionary_json.values()]
# call function to get database connection
database_connection = get_db_connection()
cursor = database_connection.cursor()
cursor.execute(
"select token_validity from logins where token_id ='" +
list_values[0] + "'")
row = cursor.fetchone()
tokenValidity = row['token_validity']
todayDate = datetime.today().strftime('%Y-%m-%d')
tokenValidityDate = tokenValidity.strftime('%Y-%m-%d')
if todayDate <= tokenValidityDate:
tempPassword = Tools.TemporaryPassword(
size=8, chars=string.ascii_uppercase + string.digits)
binary_password = bcrypt.hashpw(tempPassword.encode('utf-8'),
bcrypt.gensalt())
cursor.execute("select email from logins where token_id ='" +
list_values[0] + "'")
row = cursor.fetchall()
query = "update logins set password = %s where token_id = %s"
data = (binary_password, list_values[0])
cursor.execute(query, data)
database_connection.commit()
print("Email Fucntion")
EmailTools.TemporaryPasswordEmail(row[0]['email'], 3,
tempPassword)
print("Exit Email Function")
resp.status = falcon.HTTP_200
resp.body = json.dumps(200)
else:
resp.status = falcon.HTTP_204
resp.body = json.dumps(204)
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except pymysql.IntegrityError as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
finally:
cursor.close()
database_connection.close()
def on_get(self, req, resp, email):
try:
database_connection = get_db_connection()
cursor = database_connection.cursor()
cursor.execute("select count(1) from logins where email = '" +
email + "'")
row = cursor.fetchone()
if row['count(1)'] is 1:
cursor.execute(
"select config_value from config where config_key='validity-days'"
)
row = cursor.fetchone()
validity_days = row['config_value']
tokenID = Tools.GenerateTokenId()
query = "update logins set token_id = %s , token_validity = DATE_ADD(current_timestamp, INTERVAL %s DAY) where email = %s"
data = (tokenID, validity_days, email)
cursor.execute(query, data)
database_connection.commit()
EmailTools.ResetPasswordEmail(email, 2, tokenID)
if cursor.rowcount is 1:
resp.status = falcon.HTTP_200
resp.body = ("200")
else:
resp.status = falcon.HTTP_204
resp.body = ("204")
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except pymysql.IntegrityError as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
finally:
cursor.close()
database_connection.close()
def on_patch(self, req, resp, login_id, session):
# Authenticate login id and session availability.
try:
if (MemcacheFunctions.IsSessionValid(login_id, session) == False):
resp.status = falcon.HTTP_401
message = {
"status": "Invalid Login Credentials or Session is Expired"
}
result_json = json.dumps(message)
resp.body = result_json
return
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
try:
raw_json = req.stream.read(req.content_length or 0).decode('utf-8')
result_dictionary_json = json.loads(raw_json,
object_pairs_hook=OrderedDict,
encoding='utf-8')
order_id = result_dictionary_json['order_id']
old_status = result_dictionary_json['current_order_status_code']
desired_status = result_dictionary_json['order_status_code']
old_button_code = result_dictionary_json['current_button_code']
database_connection = get_db_connection()
cursor = database_connection.cursor()
book_status_dict = Tools.PaymentStatus(desired_status,
old_button_code)
print(book_status_dict)
book_status_list = book_status_dict['current_order_status']
action_by = book_status_dict['action_by']
if (old_status in book_status_list):
print("Entering if")
cursor.execute("select c.official_email\
from ship_orders o\
join customers c on o.login_id = c.login_id\
WHERE o.order_id = '" + order_id + "'")
row = cursor.fetchone()
cursor.execute("select l.official_email\
from ship_orders o\
join ship_quotations q on o.quotation_id = q.quotation_id\
join logistic_providers l on q.supplier_login_id = l.login_id\
where o.order_id = '" + order_id + "'")
supp_details = cursor.fetchone()
Tools.ChangePaymentStatus(order_id, desired_status, cursor,
database_connection)
resp.status = falcon.HTTP_200
resp.body = ("200")
if (desired_status == 'CREDITDEDUCTED'
and old_status == 'CONFIRMPAYMENTAMOUNT'):
EmailTools.paymentDeductedNotification(
row['official_email'])
if (desired_status == 'CREDITBLOCKED'
and old_status == 'ORDERPLACED'):
EmailTools.approveCreditBlockedNotification(
supp_details['official_email'])
else:
resp.status = falcon.HTTP_202
resp.body = ("202")
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
def on_patch(self, req, resp, login_id, session):
#Authenticate login id and session availability.
try:
if (MemcacheFunctions.IsSessionValid(login_id, session) is False):
resp.status = falcon.HTTP_401
Error = {
"Reason": "Invalid Login Credentials or Session is Expired"
}
result_json = json.dumps(Error)
resp.body = result_json
return
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400, 'Error', err.args)
try:
# Reading Json
raw_json = req.stream.read(req.content_length or 0).decode('utf-8')
resultdict_json = json.loads(raw_json,
object_pairs_hook=OrderedDict,
encoding='utf-8')
# Converting Json to List
list_values = [v for v in resultdict_json.values()]
quotation_id = list_values[0]
database_connection = get_db_connection()
cursor = database_connection.cursor()
cursor.execute(
"SELECT q.quotation_status,q.container_box_count,l.official_email\
FROM ship_quotations q\
JOIN logistic_providers l on q.supplier_login_id = l.login_id\
WHERE q.quotation_id ='" + quotation_id + "'")
row = cursor.fetchone()
if (cursor.rowcount > 0):
UserDetails = row
if (UserDetails['quotation_status'] == 'APPROVED'):
container_count = UserDetails['container_box_count']
cursor.execute("UPDATE ship_quotations\
SET ship_quotations.quotation_status = 'ACTIVE'\
WHERE ship_quotations.quotation_id ='" +
quotation_id + "'")
for i in range(container_count):
container_ID = Tools.GetContainerID(
quotation_id, 0, cursor, database_connection)
cursor.execute(
"INSERT INTO ship_containers (container_id,container_no,quotation_id,total_cbm,remaining_cbm,halal_status,number_people_sharing,percentage_full,total_weight,remaining_weight)\
SELECT '" + container_ID +
"',0,ship_quotations.quotation_id,ship_quotations.container_box_size,ship_quotations.container_box_size,'U',\
0,0,ship_quotations.air_space_size,air_space_size\
FROM ship_quotations WHERE ship_quotations.quotation_id ='"
+ quotation_id + "'")
database_connection.commit()
resp.status = falcon.HTTP_200
message = {
"Message": "Quotation ID status is updated to active."
}
result_json = json.dumps(message)
resp.body = result_json
EmailTools.UponSetUpEmailNotify(
UserDetails['official_email'], quotation_id)
else:
resp.status = falcon.HTTP_200
message = {
"Message":
"Quotation is not confirmed to be activated."
}
result_json = json.dumps(message)
resp.body = result_json
else:
resp.status = falcon.HTTP_204
message = {"Message": "Quotation status is not found."}
result_json = json.dumps(message)
resp.body = result_json
except ValueError as err:
raise resp.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except pymysql.IntegrityError as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except Exception as err:
raise resp.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
finally:
cursor.close()
database_connection.close()
def __init__(self, notes=''):
self.df = DebugFile(notes)
self.db = DatabaseTools(self.df)
self.et = EmailTools(self.df)
self.st = ScrapingTools(self.df)
self.notes = notes
class BidderSystem:
def __init__(self, notes=''):
self.df = DebugFile(notes)
self.db = DatabaseTools(self.df)
self.et = EmailTools(self.df)
self.st = ScrapingTools(self.df)
self.notes = notes
def processBatch(self, location, send_emails=True):
#Get posts for location
print('\n\ngetting posts for', location)
location_posts = self.st.getLocationPosts(location)[:6]
print('doing this many posts:', len(location_posts))
self.df.writeToDebug('getting posts for ' + location + ':\n' +
'\n'.join(location_posts))
percents = [.3, .5, .6, .7, .8, .9, 1.0]
self.df.writeToDebug('percents used: {}'.format(percents))
#For each post:
for i, post in enumerate(location_posts):
#scrape page, get info
page_info = self.st.getPageInfo(post)
print()
print(page_info.title)
if page_info.email is not None:
if not self.db.isDuplicate(page_info):
self.df.writeToDebug('post items:')
self.df.writeToDebug('{}\n'.format(
page_info.getPostItems()))
percent_offered = percents[i % len(percents)]
price_offered = self.st.getRoundPrice(
page_info.price, percent_offered)
print('offering {} percent, which is rounded to ${}\n\n'.
format(100 * percent_offered, price_offered))
self.df.writeToDebug(
'offering {} percent, which is rounded to ${}\n'.
format(100 * percent_offered, price_offered))
if abs(percent_offered - 1.0) < .01:
msg_type = 'available'
else:
msg_type = 'polite'
self.df.writeToDebug('Message type: ' + msg_type)
if send_emails:
email_id = self.et.sendEmailOffer(
page_info, price_offered, msg_type)
self.db.addToDatabase(page_info, email_id, percent_offered,
price_offered, msg_type, location)
else:
print('duplicate!')
self.df.writeToDebug('is duplicate, skipping.')
continue
else:
print('no valid email address, skipping')
self.df.writeToDebug('no valid email address, skipping')
continue
def updateDB(self, send_cancel_emails=True):
self.df.writeToDebug('Checking inbox and updating database.\n\n\n')
self.df.writeToDebug('Getting unread emails...')
new_mail = self.et.getUnreadEmails()
self.df.writeToDebug('Done.')
for mail in new_mail:
print('\n\n')
send_cancel = self.db.updateWithReply(mail)
if send_cancel_emails and send_cancel:
temp_post = self.db.getPostFromEmail(mail)
self.et.sendCancelEmail(post)
print('\n\n')
def on_patch(self, req, resp, login_id, session):
# Authenticate login id and session availability.
try:
if (MemcacheFunctions.IsSessionValid(login_id, session) == False):
resp.status = falcon.HTTP_401
message = {
"status": "Invalid Login Credentials or Session is Expired"
}
result_json = json.dumps(message)
resp.body = result_json
return
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
try:
raw_json = req.stream.read(req.content_length or 0).decode('utf-8')
result_dictionary_json = json.loads(raw_json,
object_pairs_hook=OrderedDict,
encoding='utf-8')
list_values = [v for v in result_dictionary_json.values()]
order_id = list_values[0]
old_status = list_values[1]
old_button_code = list_values[2]
desired_status = list_values[3]
database_connection = get_db_connection()
cursor = database_connection.cursor()
cursor.execute("select s.official_email\
from ship_orders o\
join ship_quotations q on o.quotation_id = q.quotation_id\
join logistic_providers s on q.supplier_login_id = s.login_id\
where o.order_id = '" + order_id + "'")
row = cursor.fetchone()
supplier_email = row['official_email']
cursor.execute("select c.official_email,o.payment_id\
from ship_orders o\
join ship_quotations q on o.quotation_id = q.quotation_id\
join customers c on o.login_id = c.login_id\
where o.order_id = '" + order_id + "'")
row = cursor.fetchone()
customer_email = row['official_email']
paymentID = row['payment_id']
print(old_status)
print(desired_status)
if (desired_status == 'CARGOSENT'):
print("inside cargo")
book_status_dict = Tools.CargoStatus(desired_status,
old_button_code)
current_booking_status = book_status_dict[
'current_order_status']
current_payment_status = book_status_dict['payment_status']
button_code_list = book_status_dict['future_button_code']
print("before payment execute")
cursor.execute(
"select payment_status_code from ship_orders where order_id = '"
+ order_id + "'")
row = cursor.fetchone()
if (old_status in current_booking_status):
index_code = current_booking_status.index(old_status)
print(current_payment_status)
if (row['payment_status_code'] in current_payment_status):
print(current_payment_status)
print("Before Tools")
Tools.ChangeBookingStatus(order_id, desired_status,
button_code_list[index_code],
cursor, database_connection)
print("After tools")
resp.status = falcon.HTTP_200
message = {
"Message": "Status is changed successfully."
}
result_json = json.dumps(message)
resp.body = result_json
EmailTools.CargoSendingAndCustomClearEmailNotify(
supplier_email, 7)
else:
print("else")
resp.status = falcon.HTTP_404
message = {"Message": "Creditblocked is not approved."}
result_json = json.dumps(message)
resp.body = result_json
else:
resp.status = falcon.HTTP_202
resp.body = ("202")
elif (desired_status == 'CARGOREADYFORPICKUP'):
book_status_dict = Tools.CargoStatus(desired_status,
old_button_code)
current_booking_status = book_status_dict[
'current_order_status']
current_payment_status = book_status_dict['payment_status']
button_code_list = book_status_dict['future_button_code']
cursor.execute(
"select payment_status_code from ship_orders where order_id = '"
+ order_id + "'")
row = cursor.fetchone()
if (old_status in current_booking_status):
index_code = current_booking_status.index(old_status)
print(current_payment_status)
if (row['payment_status_code'] in current_payment_status):
print(current_payment_status)
print("Before Tools")
Tools.ChangeBookingStatus(order_id, desired_status,
button_code_list[index_code],
cursor, database_connection)
print("After tools")
resp.status = falcon.HTTP_200
message = {
"Message": "Status is changed successfully."
}
result_json = json.dumps(message)
resp.body = result_json
else:
print("else")
resp.status = falcon.HTTP_404
message = {"Message": "Creditblocked is not approved."}
result_json = json.dumps(message)
resp.body = result_json
else:
resp.status = falcon.HTTP_202
resp.body = ("202")
elif (desired_status == 'CARGOSHIPPED'):
book_status_dict = Tools.CargoStatus(desired_status,
old_button_code)
current_booking_status = book_status_dict[
'current_order_status']
current_payment_status = book_status_dict['payment_status']
button_code_list = book_status_dict['future_button_code']
cursor.execute(
"select payment_status_code from ship_orders where order_id = '"
+ order_id + "'")
row = cursor.fetchone()
row1 = row['payment_status_code']
print(row1)
if (old_status in current_booking_status):
index_code = current_booking_status.index(old_status)
print(current_payment_status)
if (row['payment_status_code'] in current_payment_status):
print(current_payment_status)
print("Before Tools")
Tools.ChangeBookingStatus(order_id, desired_status,
button_code_list[index_code],
cursor, database_connection)
print("After tools")
resp.status = falcon.HTTP_200
message = {
"Message": "Status is changed successfully."
}
result_json = json.dumps(message)
resp.body = result_json
else:
print("else")
resp.status = falcon.HTTP_404
message = {
"Message": "CreditDeducted is not approved."
}
result_json = json.dumps(message)
resp.body = result_json
else:
resp.status = falcon.HTTP_202
resp.body = ("202")
elif (desired_status == 'LOCKEDIN'):
print(desired_status)
# hardcoded_email = "*****@*****.**"
book_status_dict = Tools.CargoStatus(desired_status,
old_button_code)
book_status_list = book_status_dict['current_order_status']
print(book_status_list)
button_code_list = book_status_dict['future_button_code']
action_by = book_status_dict['action_by']
print("before if 1")
if (old_status in book_status_list):
index_code = book_status_list.index(old_status)
print("before tools changebookingstatus")
Tools.ChangeBookingStatus(order_id, desired_status,
button_code_list[index_code],
cursor, database_connection)
EmailTools.FinalShipmentConfirmationEmailNotify(
order_id, email)
print("After emailtools")
resp.status = falcon.HTTP_200
resp.body = ("200")
elif desired_status == "ORDERDROPPED":
Tools.ChangeBookingStatus(order_id, desired_status,
'16777215', cursor,
database_connection)
resp.status = falcon.HTTP_200
resp.body = ("200")
else:
resp.status = falcon.HTTP_202
resp.body = ("202")
else:
book_status_dict = Tools.CargoStatus(desired_status,
old_button_code)
book_status_list = book_status_dict['current_order_status']
print(book_status_list)
button_code_list = book_status_dict['future_button_code']
action_by = book_status_dict['action_by']
if (old_status in book_status_list):
index_code = book_status_list.index(old_status)
Tools.ChangeBookingStatus(order_id, desired_status,
button_code_list[index_code],
cursor, database_connection)
resp.status = falcon.HTTP_200
resp.body = ("200")
if (desired_status == 'ORDERPLACED'):
EmailTools.UponOrderEmailNotify(
customer_email, paymentID)
elif desired_status == "ORDERDROPPED":
Tools.ChangeBookingStatus(order_id, desired_status,
'16777215', cursor,
database_connection)
resp.status = falcon.HTTP_200
resp.body = ("200")
else:
resp.status = falcon.HTTP_202
resp.body = ("202")
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
finally:
cursor.close()
database_connection.close()
def on_patch(self, req, resp, login_id, session):
# Authenticate login id and session availability.
try:
if (MemcacheFunctions.IsSessionValid(login_id, session) == False):
resp.status = falcon.HTTP_401
message = {
"status": "Invalid Login Credentials or Session is Expired"
}
result_json = json.dumps(message)
resp.body = result_json
return
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
try:
database_connection = get_db_connection()
cursor = database_connection.cursor()
raw_json = req.stream.read(req.content_length or 0).decode('utf-8')
result_dictionary_json = json.loads(raw_json,
object_pairs_hook=OrderedDict,
encoding='utf-8')
order_id = result_dictionary_json['order_id']
old_order_status = result_dictionary_json[
'current_order_status_code']
old_button_code = 0
desired_status = result_dictionary_json['order_status_code']
# if (desired_status == 'CLEARINGCUSTOMDEPARTURE'):
# print("Entering if")
# book_status_dict = Tools.CustomStatus(desired_status,old_button_code)
# print(book_status_dict)
# if book_status_dict == 'STATUSNOTFOUND':
# resp.status = falcon.HTTP_204
# resp.body = ("204")
# else:
# current_booking_status = book_status_dict['current_order_status']
# current_qt_status = book_status_dict['quotation_status']
# cursor.execute("select q.quotation_status\
# from ship_orders o\
# join ship_quotations q ON o.quotation_id = q.quotation_id\
# where order_id = '"+order_id+"'")
# row = cursor.fetchone()
# if(old_order_status in current_booking_status):
# if(row['quotation_status'] in current_qt_status):
# else:
# resp.status = falcon.HTTP_404
# message = {"Message":"Quotation is not closed. Unable to change status."}
# result_json = json.dumps(message)
# resp.body = result_json
# else:
# resp.status = falcon.HTTP_202
# resp.body = ("202")
# book_status_dict = Tools.CustomStatus(desired_status,old_button_code)
cursor.execute("select o.custom_status_code, c.official_email\
from ship_orders o\
join ship_quotations q ON o.quotation_id = q.quotation_id\
join customers c on o.login_id = c.login_id\
where o.order_id = '" + order_id + "'")
row = cursor.fetchone()
Tools.ChangeCustomStatus(order_id, desired_status, cursor,
database_connection)
resp.status = falcon.HTTP_200
message = {"Message": "Status is changed successfully."}
result_json = json.dumps(message)
resp.body = result_json
if (desired_status == 'CARGOCLEAREDDEPARTURE'
or desired_status == 'CARGOCLEAREDARRIVAL'):
EmailTools.CargoSendingAndCustomClearEmailNotify(
row['official_email'], 12)
# else:
# book_status_list = book_status_dict['current_order_status']
# if(old_order_status in book_status_list):
# Tools.ChangeCustomStatus(order_id,desired_status,cursor,database_connection)
# resp.status = falcon.HTTP_200
# resp.body = ("200")
# else:
# resp.status = falcon.HTTP_202
# resp.body = ("202")
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400,
traceback.print_exc(file=sys.stdout),
err.args)
# cursor = database_connection.cursor()
# cursor.execute("SELECT l.email \
# FROM logins l \
# INNER JOIN ship_orders o ON l.login_id = o.login_id \
# WHERE DATE(o.created_on) = DATE_SUB(DATE(NOW()),INTERVAL 3 DAY);")
# row = cursor.fetchall()
# print(row)
# reciepent_list = list()
# for x in row:
# reciepent_list.append(x['email'])
# print(reciepent_list)
EmailTools.AuthorizePaymentBlockEmailNotify(
"C00002S_MY_00000001_1018",
['*****@*****.**', '*****@*****.**'])
# Get current datetime from DB
# cursor.execute("SELECT NOW()")
# row = cursor.fetchone()
# current_date = row['NOW()']
# print(current_date)
# before_3days = current_date - timedelta(days=3)
# print(before_3days)
# # Query to display this data frm tbl
# cursor.execute("SELECT created_on FROM ship_orders ")
# row = cursor.fetchall()
# for x in row:
# # Check if date before 3 days exist in DB
def on_patch(self, req, resp, login_id, session):
# Authenticate login id and session availability.
try:
if (MemcacheFunctions.IsSessionValid(login_id, session) is False):
resp.status = falcon.HTTP_401
message = {"Reason": "Invalid Login Credentials or Session Expired"}
result_json = json.dumps(message)
resp.body = result_json
return
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400,traceback.print_exc(file=sys.stdout),err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400, traceback.print_exc(file=sys.stdout),err.args)
try:
# Receive customer passwords
raw_json = req.stream.read(req.content_length or 0).decode('utf-8')
result_dict_json = json.loads(raw_json,object_pairs_hook=OrderedDict, encoding='utf-8')
passwords = [v for v in result_dict_json.values()]
old_password = passwords[0]
new_password = passwords[1]
# Connecting the database
database_connection = get_db_connection()
cursor = database_connection.cursor()
cursor.execute("Select email,password from logins where login_id = '"+login_id+"'")
row = cursor.fetchone()
if row:
status = bcrypt.checkpw(old_password.encode('utf-8'),row['password'])
if status :
binary_password = bcrypt.hashpw(new_password.encode('utf-8'),bcrypt.gensalt())
similar = bcrypt.checkpw(old_password.encode('utf-8'),binary_password)
print(similar)
if not similar:
Tools.ChangePassword(login_id, binary_password,cursor,database_connection)
EmailTools.changePasswordNotification(row['email'])
resp.status = falcon.HTTP_200
message = {"status": "Your password is successfully updated"}
result_json = json.dumps(message)
resp.body = (result_json)
else:
resp.status = falcon.HTTP_200
message = {"status": "New password can not be same as current password. Please enter different password."}
result_json = json.dumps(message)
resp.body = (result_json)
else:
resp.status = falcon.HTTP_200
message = {"status": "Incorrect Password Entered"}
result_json = json.dumps(message)
resp.body = (result_json)
else:
resp.status = falcon.HTTP_204
message = {"status": "No Content"}
result_json = json.dumps(message)
resp.body = (result_json)
except ValueError as err:
raise falcon.HTTPError(falcon.HTTP_400, traceback.print_exc(file=sys.stdout) , err.args)
except pymysql.IntegrityError as err:
raise falcon.HTTPError(falcon.HTTP_400, traceback.print_exc(file=sys.stdout) , err.args)
except Exception as err:
raise falcon.HTTPError(falcon.HTTP_400, traceback.print_exc(file=sys.stdout) , err.args)
finally:
cursor.close()
database_connection.close()