def setting(sms_to, sms_from, sms_list):
# Add analytics record
instance_name, a = config_services.identify_service(sms_to)
bb_dbconnector_factory.DBConnectorInterfaceFactory().create().add_analytics_record("Count", "Command-SETTING", instance_name)
# Make sure that there are enough values in the message to actually change a setting
# You need three - 1. SET, 2. SETTING (e.g. EMAIL), 3. VALUE (e.g. ON)
if len(sms_list) >= 3:
# Firstly check to see which setting the user wishes to update
if sms_list[1].upper() == "EMAIL":
logger.debug("User changing email settings")
email_settings(sms_to, sms_from, sms_list)
elif sms_list[1].upper() == "CONTACT":
logger.debug("User changing contact settings")
contact_settings(sms_to, sms_from, sms_list)
else:
return
return
else:
bb_sms_handler.send_sms_notification(sms_to, sms_from,
"Please ensure you provide all the necessary parameters to change settings. ")
return
def unregister(smsrequest):
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_analytics_record("Count", "Command-UNREGISTER",
smsrequest.instancename)
if len(smsrequest.requestcommandlist) < 2:
return notEnoughDeRegistrationDetails(smsrequest.servicenumber,
smsrequest.requestormobile)
if len(smsrequest.requestcommandlist) > 2:
message = "You have provided too many details in your text. Unregister text should be 'UNREGISTER AB125DF'."
bb_sms_handler.send_sms_notification(smsrequest.servicenumber,
smsrequest.requestormobile,
message)
return "<Response></Response>"
try:
smsrequest.requestorreg = smsrequest.requestcommandlist[1].upper()
if bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).remove_registration(smsrequest.requestorreg,
smsrequest.requestormobile) == 1:
message = "Car " + smsrequest.requestorreg + " has been unregistered from BlockBuster."
logger.debug(message)
bb_sms_handler.send_sms_notification(smsrequest.servicenumber,
smsrequest.requestormobile,
message)
elif bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).remove_registration(smsrequest.requestorreg,
smsrequest.requestormobile) == 0:
message = "Car is not registered to this mobile number."
logger.debug(message)
bb_sms_handler.send_sms_notification(smsrequest.servicenumber,
smsrequest.requestormobile,
message)
elif bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).remove_registration(smsrequest.requestorreg,
smsrequest.requestormobile) == -1:
message = "Unable to unregister car " + smsrequest.requestorreg + " - please report the issue."
logger.error("Unable to unregister car " +
smsrequest.requestorreg + ".")
bb_sms_handler.send_sms_notification(smsrequest.servicenumber,
smsrequest.requestormobile,
message)
else:
raise Exception("Unable to unregister this car at this time.")
logger.error("Unable to unregister car at this time.")
except Exception, e:
bb_auditlogger.BBAuditLoggerFactory().create().logException(e)
message = "Unable to unregister car " + smsrequest.requestorreg + " - please report the issue."
logger.error("Unable to unregister car " + smsrequest.requestorreg +
".")
bb_sms_handler.send_sms_notification(smsrequest.servicenumber,
smsrequest.requestormobile,
message)
def whois(SMSTo, SMSFrom, SMSList):
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_analytics_record("Count", "Command-WHOIS", instancename)
if len(SMSList) > 1:
upper_case_reg = SMSList[1].upper()
logger.debug("Using Registration Plate: " + upper_case_reg)
response = cardetails(upper_case_reg)
else:
response = respond_noregistrationspecified(SMSTo, SMSFrom)
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom, response)
def current_status(smsrequest):
# Get the current status for the requesting user
status = blockbuster.bb_command_processor.current_status(smsrequest)
active_blocks_as_blockee = status['blockedBy']
active_blocks_as_blocker = status['blocking']
# Check the list of people you are blocking in
if len(active_blocks_as_blockee) > 0:
text_list_of_blocks_as_blockee = "Currently being blocked by:\n\n"
for b in active_blocks_as_blockee:
blocker_name = bb_dbconnector_factory.DBConnectorInterfaceFactory()\
.create().get_name_from_mobile(b['blocker'])
text_list_of_blocks_as_blockee = text_list_of_blocks_as_blockee + blocker_name + "\n"
else:
text_list_of_blocks_as_blockee = "Not currently blocked in.\n"
# Check the list of people blocking you in
if len(active_blocks_as_blocker) > 0:
text_list_of_blocks_as_blocker = "Currently blocking:\n\n"
for b in active_blocks_as_blocker:
blocked_reg = b['blocked_reg']
blocked_name = bb_dbconnector_factory.DBConnectorInterfaceFactory()\
.create().get_name_from_mobile(b['blockee'])
text_list_of_blocks_as_blocker = text_list_of_blocks_as_blocker + blocked_name + " (" + blocked_reg + ")\n"
else:
text_list_of_blocks_as_blocker = "Not currently blocking anyone in."
status_message = text_list_of_blocks_as_blockee + "\n" + text_list_of_blocks_as_blocker
# Send the current status back to the user via SMS
bb_sms_handler.send_sms_notification(smsrequest.servicenumber,
smsrequest.requestormobile,
status_message)
# Also send them their current status via email
email_subject = "Current BlockBuster Status"
email_message = status_message
bb_notification_handler.send_notifications(smsrequest.requestormobile,
email_subject, email_message)
return
def send_unblock_blockee_messages(service_number, unblocker_number,
blockee_number, blocked_reg,
blocker_name, blockee_name):
messageblockee = blocker_name + " is no longer blocking your car (" + blocked_reg + ") in."
bb_sms_handler.send_sms_notification(service_number, blockee_number,
messageblockee)
#Send a push notification if the user wants it
subject = "You've been unblocked"
send_push_notification_if_appropriate(service_number, blockee_number,
subject, messageblockee)
# Ask the notification handler to send out the appropriate notifications
bb_notification_handler.send_notifications(blockee_number, subject,
messageblockee)
def push(SMSTo, SMSFrom, SMSList):
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_analytics_record("Count", "Command-PUSH", instancename)
if len(SMSList) > 1:
if SMSList[1].upper() == "OFF":
logger.debug("User requested that push notifications are disabled")
message = bb_dbconnector_factory.DBConnectorInterfaceFactory(
).create().turn_push_notifications_off(SMSFrom)
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom, message)
return
elif SMSList[1].upper() == "ON":
logger.debug("User requested that push notifications are enabled")
message = bb_dbconnector_factory.DBConnectorInterfaceFactory(
).create().turn_push_notifications_on(SMSFrom)
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom, message)
return
else:
pushover_token = SMSList[1]
logger.debug("Using Pushover token " + pushover_token)
logger.debug("Setting Pushover token for user")
message = bb_dbconnector_factory.DBConnectorInterfaceFactory(
).create().add_pushover_token_for_user(SMSFrom, pushover_token)
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom, message)
else:
return
def register(SMSTo, SMSFrom, SMSList, location):
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_analytics_record("Count", "Command-REGISTER", instancename)
if len(SMSList) < 4:
return notEnoughRegistrationDetails(SMSTo, SMSFrom)
registration = SMSList[1].upper()
firstname = SMSList[2]
surname = SMSList[3]
mobile = SMSFrom
location = location
message = bb_dbconnector_factory.DBConnectorInterfaceFactory()\
.create()\
.register_new_car(registration,
firstname,
surname,
mobile,
location)
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom, message)
return
def acknowledge_move_request(SMSTo, SMSFrom, SMSList):
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_analytics_record("Count", "Command-ACKNOWLEDGE", instancename)
open_move_requests = bb_dbconnector_factory.DBConnectorInterfaceFactory(
).create().get_open_move_requests(SMSFrom)
blocker_name = bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).get_name_from_mobile(SMSFrom)
if len(open_move_requests) < 1:
bb_sms_handler.send_sms_notification(
SMSTo, SMSFrom,
"BlockBuster doesn't know of anyone waiting for you to move at this time."
)
return
for move_request in open_move_requests:
message = blocker_name + " has acknowledged your move request."
bb_sms_handler.send_sms_notification(SMSTo,
move_request['blockee_mobile'],
message)
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).remove_move_request(SMSFrom, move_request['blockee_mobile'])
return
def email_settings(sms_to, sms_from, sms_list):
if sms_list[2].upper() == "OFF":
logger.debug("User requested that email notifications are disabled")
result = bb_dbconnector_factory.DBConnectorInterfaceFactory().create().disable_email_notifications(sms_from)
bb_sms_handler.send_sms_notification(sms_to, sms_from, result)
return
elif sms_list[2].upper() == "ON":
logger.debug("User requested that email notifications are enabled")
result = bb_dbconnector_factory.DBConnectorInterfaceFactory().create().enable_email_notifications(sms_from)
bb_sms_handler.send_sms_notification(sms_to, sms_from, result)
notify.send_notifications(sms_from, "Test Notification", "Email notifications have now been turned on. "
"You should add [email protected] "
"to your contacts.")
return
else:
email_address = sms_list[2]
logger.debug("Updating with email address " + email_address)
result = bb_dbconnector_factory.DBConnectorInterfaceFactory().create().update_email_address(sms_from, email_address)
bb_sms_handler.send_sms_notification(sms_to, sms_from, result)
notify.send_notifications(sms_from, "Test Notification", "Notifications are now enabled for this email address.")
return
def notEnoughDeRegistrationDetails(SMSTo, SMSFrom):
logger.debug("Returning: Not Enough Details Provided")
message = "You have not provided enough details. Please use format: \n \n'UNREGISTER FD05RYT'"
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom, message)
return "<Response></Response>"
def send_move_blockee_message(service_number2, requester_number2,
names_list):
messageblocker = "I've asked these people to move: \n\n" + names_list
bb_sms_handler.send_sms_notification(service_number2,
requester_number2, messageblocker)
def request_single_car_move(reg):
# Search the database for the registration plate provided
if checkifregexists(reg):
# Try and retrieve details from the database for both the blockEE and blockER
try:
dict_blocker = bb_dbconnector_factory.DBConnectorInterfaceFactory().create()\
.get_user_dict_from_reg(blocking_reg)
print(dict_blocker)
dict_blockee = bb_dbconnector_factory.DBConnectorInterfaceFactory().create()\
.get_user_dict_from_mobile(requester_number)
print(dict_blockee)
except Exception, e:
bb_auditlogger.BBAuditLoggerFactory().create().logException(e)
pass
# If the blocker has a Mobile number (and therefore is registered with BlockBuster) then do this
if dict_blocker['Mobile'] != "" and dict_blocker['Mobile'] != None:
# If the blockee is registered with BlockBuster then do this
if dict_blockee:
message = dict_blockee['FirstName'] + " " + dict_blockee['Surname'] + \
" needs you to move your car, please.\n\n" \
"Text 'OK' to confirm that you have received this."
subject = "Please move your car"
bb_sms_handler.send_sms_notification(
service_number, dict_blocker['Mobile'], message)
# Send a push notification if that user wants them
send_push_notification_if_appropriate(
service_number, dict_blocker['Mobile'], subject,
message)
# Ask the notification handler to send out the appropriate notifications
bb_notification_handler.send_notifications(
dict_blocker['Mobile'], subject, message)
# Open a move request for that blocker / blockee combination
add_move_request(dict_blocker['Mobile'], requester_number)
landline_string = get_landline_number_string(blocking_reg)
logger.debug(landline_string)
blocker_name = dict_blocker[
'FirstName'] + " " + dict_blocker['Surname']
blocker_mobile = dict_blocker['Mobile']
blocker_reg = reg
list_of_names = blocker_name + " (" + \
blocker_reg + ")\n" + \
include_mobile_number(blocker_mobile) + \
get_landline_number_string(blocker_reg) + "\n"
send_move_blockee_message(service_number, requester_number,
list_of_names)
# The blockee is not registered with BlockBuster
# so advise them to register with the service before trying to use it
else:
bb_sms_handler.send_sms_notification(
service_number, requester_number,
"Sorry - please register this mobile number to use "
"this BlockBuster service. \n \n Text '?' for help.")
# The blockER is not registered with BlockBuster
# so provide them the name of the car owner
else:
bb_sms_handler.send_sms_notification(
service_number, requester_number,
"Sorry - this car belongs to " +
dict_blocker['FirstName'] + " " + dict_blocker['Surname'] +
" but they do not have a mobile "
"number registered.")
def contact_settings(bb_service_number, user_mobile, sms_list):
# If the user sends a command of "SET CONTACT MOBILE OFF", mobile number sharing for them will be disabled.
if len(sms_list) > 3 and sms_list[2].upper() == "MOBILE" and sms_list[3].upper() == "OFF":
# Log that the user has chosen to disable sharing of their mobile number
logger.debug("Updating user setting Share_Mobile to OFF")
# Attempt to disable mobile number sharing for this user - will return a success code of 0 (success) or 1 (fail)
success_code = bb_dbconnector_factory.DBConnectorInterfaceFactory()\
.create().disable_mobile_number_sharing(user_mobile)
if success_code == 0:
result = "Share Mobile Number is now OFF."
logger.info("User Setting Updated: Share Mobile OFF")
elif success_code == 1:
result = "There was an issue enabling this setting - please contact BlockBuster support."
logger.error("Error disabling Share Mobile setting for user.")
bb_sms_handler.send_sms_notification(bb_service_number, user_mobile, result)
return
# If the user sends any other command beginning with "SET CONTACT MOBILE"
# then mobile number sharing will be enabled for them.
elif sms_list[2].upper() == "MOBILE":
# Log that the user has chosen to enable sharing of their mobile number
logger.debug("Updating user setting Share_Mobile to ON")
# Attempt to enable mobile number sharing for this user - will return a success code of 0 (success) or 1 (fail)
success_code = bb_dbconnector_factory.DBConnectorInterfaceFactory()\
.create().enable_mobile_number_sharing(user_mobile)
if success_code == 0:
result = "Share Mobile Number is now ON."
logger.info("User Setting Updated: Share Mobile ON")
elif success_code == 1:
result = "There was an issue enabling this setting - please contact BlockBuster support."
logger.error("Error enabling Share Mobile setting for user.")
bb_sms_handler.send_sms_notification(bb_service_number, user_mobile, result)
return
# If the user sends a "SET CONTACT CLEAR" command
# erase any alternative contact text that they have set and enable mobile sharing
elif sms_list[2].upper() == "CLEAR":
# Log that the user has chosen to enable sharing of their mobile number
logger.debug("Clearing alternative contact text and enabling mobile sharing")
bb_auditlogger.BBAuditLoggerFactory().create().logAudit('app',
'SETTING-CONTACT-CLEAR',
"Mobile:" + user_mobile)
# Attempt to enable mobile number sharing for this user - will return a success code of 0 (success) or 1 (fail)
success_clear = bb_dbconnector_factory.DBConnectorInterfaceFactory()\
.create().remove_alternative_contact_text(user_mobile)
success_code = bb_dbconnector_factory.DBConnectorInterfaceFactory()\
.create().enable_mobile_number_sharing(user_mobile)
if success_code == 0 and success_clear == 0:
result = "Your additional contact information has been cleared and mobile number sharing is enabled."
logger.info("User Setting Updated: Share Mobile ON and Alternative Contact Info CLEARED.")
elif success_code == 1 or success_clear == 1:
result = "There was an issue clearing your contact information - please report this issue."
# TODO: Create a new logError method on the BBAuditLogger and then convert the below
# BBAuditLogger.BBAuditLoggerFactory().create().logException('app',
# 'SETTING-CONTACT-CLEAR',
# "Mobile:" + user_mobile)
bb_sms_handler.send_sms_notification(bb_service_number, user_mobile, result)
return
else:
# Assign the alternative text provided by the user to a variable
alt_text_last_index = (len(sms_list))
alternative_text = sms_list[2]
i = 3
while i < alt_text_last_index:
alternative_text = alternative_text + " " + sms_list[i]
i += 1
# Log that the user has chosen to update their alternative contact information
logger.info("Updating user setting with alternative contact information.")
logger.debug("New contact information: " + alternative_text)
# Call the method in the DAL to update the alternative contact information for that user.
# Assign the result to a variable.
success_code = bb_dbconnector_factory.DBConnectorInterfaceFactory()\
.create()\
.update_alternative_contact_text(user_mobile, alternative_text)
if success_code == 0:
result = "Alternative contact info has been set to:\n\n \"" + alternative_text + "\""
elif success_code == 1:
result = "There was an issue setting the alternative contact info - please contact BlockBuster support."
# Send an SMS to the user confirming that their details have been updated.
bb_sms_handler.send_sms_notification(bb_service_number, user_mobile, result)
return
# The blockER is not registered with BlockBuster
# so provide them the name of the car owner
else:
bb_sms_handler.send_sms_notification(
service_number, requester_number,
"Sorry - this car belongs to " +
dict_blocker['FirstName'] + " " + dict_blocker['Surname'] +
" but they do not have a mobile "
"number registered.")
else:
# If the MOVE command was sent on its own (therefore searching for existing blocks)
if len(SMSList) < 2:
bb_sms_handler.send_sms_notification(
service_number, requester_number,
"Sorry - cannot find any current blocks for you.")
# In which case it must have been sent with a registration plate as a parameter
else:
bb_sms_handler.send_sms_notification(
service_number, requester_number,
"Sorry - vehicle not registered with BlockBuster.")
return "<Response></Response>"
# Method to send MOVE response to blockee where there is a list of blockers who have been informed.
def send_move_blockee_message(service_number2, requester_number2,
names_list):
messageblocker = "I've asked these people to move: \n\n" + names_list
bb_sms_handler.send_sms_notification(service_number2,
def process_twilio_request(request):
logger.debug(
'################################ NEW SMS ###############################################'
)
if not within_operational_period():
logger.info("Time restriction mode enabled - ignoring request")
return "<Response></Response>"
# Create an instance of an smsrequest object
smsrequest = bb_types.SMSRequestFactory().create()
# Extract some information from the http requests
SMSFrom = str(request.form['From'])
SMSTo = str(request.form['To'])
# Strip whitespace from the beginning and end of the body of the message
SMSBody = str(request.form['Body']).rstrip().lstrip()
# Populate the smsrequest instance with details of the received request
smsrequest.requestormobile = str(request.form['From'])
smsrequest.servicenumber = str(request.form['To'])
smsrequest.requestbody = str(request.form['Body']).rstrip().lstrip()
global instancename
global location
instancename, location = config_services.identify_service(SMSTo)
smsrequest.instancename = instancename
SMSList = combinesplitregistrations(SMSBody, location)
smsrequest.requestcommandlist = SMSList
# Set the SMS Service Name to 'Twilio'
smsservice = "Twilio"
smsrequest.requestsmsservice = smsservice
# Add an analytics record for the received request
bb_dbconnector_factory.DBConnectorInterfaceFactory()\
.create()\
.add_analytics_record("Count", "SMS-Receive", instancename)
# Construct a dictionary containing details for creating a message log entry
logentry = {
"Direction":
"I <----",
"SMSService":
smsservice,
"Command":
"",
"Originator":
SMSFrom,
"OriginatorName":
bb_dbconnector_factory.DBConnectorInterfaceFactory().create().
get_name_from_mobile(SMSFrom),
"Destination":
SMSTo,
"RecipientName":
instancename,
"Details":
SMSBody
}
# Construct a dictionary containing details for creating an audit log entry
audit_entry = "Originator:" + SMSFrom + \
";Receipient:" + SMSTo + \
";Body:" + SMSBody
# Check the incoming message to see which function has been requested
commandelement = smsrequest.get_command_element()
# Define lists of aliases for some of the commands
start_command_list = ['START']
help_command_list = ['?']
move_command_list = ['MOVE', 'M']
block_command_list = ['BLOCK', 'B']
unblock_command_list = ['UNBLOCK', 'U']
unregister_command_list = ['UNREGISTER', 'UR']
# First, check if the command is one of the following public commands - if so, process the registration.
if commandelement == "REGISTER":
logentry['Command'] = "REGISTER"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-REGISTER', audit_entry)
logger.debug("REGISTER Command Received")
register(SMSTo, SMSFrom, SMSList, location)
return "<Response></Response>"
if commandelement in start_command_list:
logentry['Command'] = "START"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-START', audit_entry)
workflow.command_start.go(smsrequest)
return "<Response></Response>"
if commandelement in help_command_list:
logentry['Command'] = "HELP"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-HELP', audit_entry)
workflow.command_help.go(smsrequest)
return "<Response></Response>"
# If not a registration, proceed to check that the requesting user is registered with the service.
logger.debug("Checking that user is registered...")
# If the user is not registered, respond asking them to register and write log entries
if not bb_dbconnector_factory.DBConnectorInterfaceFactory().create()\
.number_is_registered(smsrequest.requestormobile):
logger.debug("User is not registered to use this service")
send_not_registered_SMS(SMSTo, SMSFrom)
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'NOT-REGISTERED', audit_entry)
return "<Response></Response>"
if commandelement in unregister_command_list:
logger.debug("UNREGISTER Command Received")
logentry['Command'] = "UNREGISTER"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-UNREGISTER', audit_entry)
return unregister(smsrequest)
elif commandelement == "WHOIS":
logger.debug("WHOIS Command Received")
logentry['Command'] = "WHOIS"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-WHOIS', audit_entry)
whois(SMSTo, SMSFrom, SMSList)
return "<Response></Response>"
elif commandelement in move_command_list:
logger.debug("MOVE Command Received")
logentry['Command'] = "MOVE"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-MOVE', audit_entry)
return move(SMSTo, SMSFrom, SMSList)
elif commandelement in block_command_list:
logger.debug("BLOCK Command Received")
logentry['Command'] = "BLOCK"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-BLOCK', audit_entry)
return block(SMSTo, SMSFrom, SMSList)
elif commandelement in unblock_command_list:
logger.debug("UNBLOCK Command Received")
logentry['Command'] = "UNBLOCK"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-UNBLOCK', audit_entry)
return unblock(SMSTo, SMSFrom, SMSList)
elif commandelement == "OK":
logger.debug("MOVE Request Acknowledged")
logentry['Command'] = "OK"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-ACK', audit_entry)
acknowledge_move_request(SMSTo, SMSFrom, SMSList)
return "<Response></Response>"
elif commandelement == ".":
logger.debug("STATUS Command Received")
logentry['Command'] = "STATUS"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-STATUS', audit_entry)
current_status(smsrequest)
return "<Response></Response>"
elif commandelement == "PUSH":
logger.debug("PUSH Command Received")
logentry['Command'] = "ADD_PUSHOVER_TOKEN"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-SETTING', audit_entry)
push(SMSTo, SMSFrom, SMSList)
return "<Response></Response>"
elif commandelement == "SET":
logger.debug("SET Command Received")
logentry['Command'] = "SETTING"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-SETTING', audit_entry)
user_settings.setting(SMSTo, SMSFrom, SMSList)
return "<Response></Response>"
else:
logger.debug("Command Not Recognised - Assuming WHOIS")
logentry['Command'] = "WHOIS"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_transaction_record(logentry)
bb_auditlogger.BBAuditLoggerFactory().create().logAudit(
'app', 'RCVCMD-WHOIS', audit_entry)
# Format the registration number so that it is all capitals
uppercasereg = SMSBody.upper().replace(" ", "")
logger.debug("Using Registration Plate: " + uppercasereg)
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom,
cardetails(uppercasereg))
return "<Response></Response>"
def respond_noregistrationspecified(ServiceNumber, RecipientNumber):
logger.debug("Returning: No Registration Specified")
message = "You didn't provide a registration. \n \n Text '?' for help."
bb_sms_handler.send_sms_notification(ServiceNumber, RecipientNumber,
message)
return "<Response></Response>"
def block(SMSTo, SMSFrom, SMSList):
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_analytics_record("Count", "Command-BLOCK", instancename)
# Loop through the registrations provided and add them all to an array
reg_list = []
total_elements = len(SMSList)
# Start at element[1} as we have already established that element[0] contains the command by the face we're here.
e = 1
while e < total_elements:
# Skip elements which have come from multiple spaces between registrations in the message.
if SMSList[e] == "":
pass
else:
reg_list.append(SMSList[e])
e += 1
logger.debug("Number of registrations in list is " + str(len(reg_list)))
# Check that a registration was actually provided. If not, respond to the user.
if len(reg_list) < 1:
return respond_noregistrationspecified(SMSTo, SMSFrom)
# Now work through each of the registrations in the list, working out what the status is, and triggering a
# notification message if appropriate. Also build up a list of the statuses so that they can be fed back to
# the user.
list_of_blockees = ""
for registration in reg_list:
logger.debug("Currently processing " + registration)
blocked_reg = registration.upper()
# TODO: Refactor the registered check out of this as this is now done at first receipt of the web request
try:
dict_blocker = bb_dbconnector_factory.DBConnectorInterfaceFactory().create()\
.get_user_dict_from_mobile(SMSFrom)
logger.debug("Surname of Blocker is " + dict_blocker['Surname'])
except Exception, e:
bb_auditlogger.BBAuditLoggerFactory().create().logException(e)
message = "Sorry - please register this mobile number to use this BlockBuster service. \n \n " \
"Text '?' for help."
# Send message to the blocker to advise them to register in order to use the service.
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom, message)
return "<Response></Response>"
# Search the database for the registration number provided
if checkifregexists(registration.upper()):
try:
dict_blockee = bb_dbconnector_factory.DBConnectorInterfaceFactory().create()\
.get_user_dict_from_reg(registration.upper())
logger.debug("Surname of blockee is " +
dict_blockee['Surname'])
except Exception, e:
bb_auditlogger.BBAuditLoggerFactory().create().logException(e)
pass
# If the blockee does not have a mobile number registered, tell the blocker that they can't be notified,
# and then continue with the next iteration of the loop.
if dict_blockee['Mobile'] == '' or dict_blockee['Mobile'] is None:
list_of_blockees = list_of_blockees + registration.upper() + ": " + "Not Registered (" + dict_blockee['FirstName'] + " " \
+ dict_blockee['Surname'] + ")\n\n"
continue
# Create the message to be sent to the person being blocked in.
messageblockee = dict_blocker['FirstName'] + " " + dict_blocker['Surname'] + " has blocked in your car " \
+ blocked_reg + ". \n\nText MOVE to ask them to move their car."
# Send the message to the blockee.
bb_sms_handler.send_sms_notification(SMSTo, dict_blockee['Mobile'],
messageblockee)
#Send a push notification if the user wants it
subject = "You've been blocked in"
send_push_notification_if_appropriate(SMSTo,
dict_blockee['Mobile'],
subject, messageblockee)
# Ask the notification handler to send out the appropriate notifications
bb_notification_handler.send_notifications(dict_blockee['Mobile'],
subject, messageblockee)
# Construct the list of blockees
list_of_blockees = list_of_blockees + registration.upper() + ": " + "Notified (" + dict_blockee['FirstName'] + " " \
+ dict_blockee['Surname'] + ")\n\n"
# Construct a block record
block_parameters = {
"BlockedReg": blocked_reg,
"BlockeeMobile": dict_blockee['Mobile'],
"BlockerMobile": SMSFrom
}
# Add the block record to the DB
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_block_record(block_parameters)
def featurenotimplemented(SMSTo, SMSFrom, SMSList):
logger.debug("Returning: Not Implemented")
message = "Sorry, feature not implemented yet. \n \n Text '?' for help."
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom, message)
return "<Response></Response>"
def unblock(SMSTo, SMSFrom, SMSList):
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).add_analytics_record("Count", "Command-UNBLOCK", instancename)
def send_unblock_blockee_messages(service_number, unblocker_number,
blockee_number, blocked_reg,
blocker_name, blockee_name):
messageblockee = blocker_name + " is no longer blocking your car (" + blocked_reg + ") in."
bb_sms_handler.send_sms_notification(service_number, blockee_number,
messageblockee)
#Send a push notification if the user wants it
subject = "You've been unblocked"
send_push_notification_if_appropriate(service_number, blockee_number,
subject, messageblockee)
# Ask the notification handler to send out the appropriate notifications
bb_notification_handler.send_notifications(blockee_number, subject,
messageblockee)
def send_unblock_blocker_message(service_number, unblocker_number,
list_of_names):
messageblocker = "I've told these people that you've moved: \n\n" + list_of_names
bb_sms_handler.send_sms_notification(service_number, unblocker_number,
messageblocker)
# Check whether the UNBLOCK command was sent on its own....
if len(SMSList) < 2:
logger.debug('Command: UNBLOCK (no reg)')
list_of_blocks = bb_dbconnector_factory.DBConnectorInterfaceFactory(
).create().get_list_of_blocks_for_blocker(SMSFrom)
# Check the length of the cursor to see how many active blocks there are
# If there is at least one active block, process those blocks...
if len(list_of_blocks) > 0:
list_of_names = ""
# Iterate through the cursor and process each active block.
# Send a message to the blockee, and remove the block.
for block_item in list_of_blocks:
a = SMSTo
b = SMSFrom
c = block_item['blockee_mobile']
d = block_item['blocked_reg']
blocker_name = bb_dbconnector_factory.DBConnectorInterfaceFactory(
).create().get_name_from_mobile(b)
blockee_name = bb_dbconnector_factory.DBConnectorInterfaceFactory(
).create().get_name_from_reg(d)
send_unblock_blockee_messages(a, b, c, d, blocker_name,
blockee_name)
list_of_names = list_of_names + blockee_name + "\n"
bb_dbconnector_factory.DBConnectorInterfaceFactory().create(
).remove_blocks(b, d)
# Now send a message to the blocker containing a list of all people who were being blocked.
send_unblock_blocker_message(SMSTo, SMSFrom, list_of_names)
return "<Response></Response>"
# If there are no active blocks, inform the unblocker that there are no active blocks found
else:
logger.debug("No active blocks found.")
bb_sms_handler.send_sms_notification(
SMSTo, SMSFrom, "You are not currently blocking anyone in.")
return "<Response></Response>"
# ... or if a registration plate was specified with the UNBLOCK command
else:
try:
blocked_reg = SMSList[1].upper()
except Exception, e:
bb_auditlogger.BBAuditLoggerFactory().create().logException(e)
logger.warn('No Registration Specified')
respond_noregistrationspecified(SMSTo, SMSFrom)
return "<Response></Response>"
# Search the database for the registration number provided
if checkifregexists(blocked_reg):
try:
dict_blockee = bb_dbconnector_factory.DBConnectorInterfaceFactory().create()\
.get_user_dict_from_reg(blocked_reg)
logger.debug(dict_blockee['Surname'])
except Exception, e:
bb_auditlogger.BBAuditLoggerFactory().create().logException(e)
logger.error("Error retrieving user dictionary from reg \n" +
str(e))
pass
if dict_blockee['Mobile'] == "" or dict_blockee['Mobile'] is None:
message = "Sorry - that car belongs to " + dict_blockee['FirstName'] + " " \
+ dict_blockee['Surname'] + " but they do not have a mobile number registered."
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom, message)
return "<Response></Response>"
try:
dict_blocker = bb_dbconnector_factory.DBConnectorInterfaceFactory().create()\
.get_user_dict_from_mobile(SMSFrom)
logger.debug(dict_blocker['Surname'])
except Exception, e:
bb_auditlogger.BBAuditLoggerFactory().create().logException(e)
message = "Sorry - please register this mobile number to use this BlockBuster service. \n \n " \
"Text '?' for help."
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom, message)
return "<Response></Response>"
def notEnoughBlockDetails(SMSTo, SMSFrom):
logger.debug("Returning: Not Enough Details Provided")
message = "You have not provided enough details. Please use format: \n \n'BLOCK FD05RYT' \n \nwith the registration as a single word."
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom, message)
return "<Response></Response>"
def send_unblock_blocker_message(service_number, unblocker_number,
list_of_names):
messageblocker = "I've told these people that you've moved: \n\n" + list_of_names
bb_sms_handler.send_sms_notification(service_number, unblocker_number,
messageblocker)
def send_not_registered_SMS(SMSTo, SMSFrom):
logger.debug("Returning: Please Register To Use This Service")
message = "Please register to use BlockBuster. \n \nSimply text 'REGISTER YourNumberPlate Firstname Surname'."
bb_sms_handler.send_sms_notification(SMSTo, SMSFrom, message)
return None
