def test_DatabaseCreateTableDict(self):
message_data = database.DatabaseDataMessage()
NOW = datetime.datetime.now()
data_dict = {}
data_dict[0] = ("TEST_TEXT", """ "This is some text to test with" """)
data_dict[1] = ("TEST_INT", 1234)
data_dict[2] = ("TEST_FLOAT", 3.1415)
data_dict[3] = ("TEST_BLOB", """ "???????????" """)
data_dict[4] = ("TEST_DATE",
""" "{}" """.format(NOW.strftime("%m-%d-%Y")))
data_dict[5] = ("TEST_TIME",
""" time("{}") """.format(NOW.strftime("%H:%M:%S")))
message_data.data_dict = data_dict
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_CREATE_TABLE_DICT,
message=message_data)
self.db_queue.put(message)
message_data = database.DatabaseDataMessage(
table_name="test", caller_queue=self.response_queue)
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_LIST_TABLE_COLUMNS,
message=message_data)
self.db_queue.put(message)
while self.response_queue.empty():
pass
data = self.response_queue.get()
print(data)
self.assertListEqual(data, [
'ID', 'TEST_TEXT', 'TEST_INT', 'TEST_FLOAT', 'TEST_BLOB',
'TEST_DATE', 'TEST_TIME'
])
return
def test_DatabaseInsertAndSelectData(self):
# Create Table
message_data = database.DatabaseDataMessage(
caller_queue=self.response_queue)
message_data.schema_file = "test_table1.sql"
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_CREATE_TABLE_SCHEMA,
message=message_data)
self.db_queue.put(message)
# Populate Table
message_data = database.DatabaseDataMessage(
table_name="test", caller_queue=self.response_queue)
NOW = datetime.datetime.now()
data_dict = {}
data_dict[0] = ("TEST_TEXT", """ "This is some text to test with" """)
data_dict[1] = ("TEST_INT", 1234)
data_dict[2] = ("TEST_FLOAT", 3.1415)
data_dict[3] = ("TEST_BLOB", """ "???????????" """)
data_dict[4] = ("TEST_DATE",
""" "{}" """.format(NOW.strftime("%m-%d-%Y")))
data_dict[5] = ("TEST_TIME",
""" time("{}") """.format(NOW.strftime("%H:%M:%S")))
message_data.data_dict = data_dict
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_INSERT_DATA,
message=message_data)
self.db_queue.put(message)
time.sleep(1)
# Retrieve data and check
del (message)
del (self.response_queue)
self.response_queue = queue.Queue()
message_data = database.DatabaseDataMessage(
table_name="test",
field="TEST_INT",
data=1234,
caller_queue=self.response_queue)
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_SELECT_DATA,
message=message_data)
self.db_queue.put(message)
print("WAITING.....")
# while self.response_queue.empty():
results = self.response_queue.get()
print(results)
self.assertEqual(results[0][0], 1)
self.assertEqual(results[0][1], "This is some text to test with")
self.assertEqual(results[0][2], 1234)
self.assertEqual(results[0][3], 3.1415)
self.assertEqual(results[0][4], "???????????")
self.assertEqual(results[0][5], NOW.strftime("%m-%d-%Y"))
self.assertEqual(results[0][6], NOW.strftime("%H:%M:%S"))
return
def test_DatabaseDeleteTable(self):
# Create Table
message_data = database.DatabaseDataMessage()
message_data.schema_file = "test_table1.sql"
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_CREATE_TABLE_SCHEMA,
message=message_data)
self.db_queue.put(message)
# Confirm that worked
message_data = database.DatabaseDataMessage(
table_name="test", caller_queue=self.response_queue)
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_LIST_TABLE_COLUMNS,
message=message_data)
self.db_queue.put(message)
while self.response_queue.empty():
pass
data = self.response_queue.get()
print(data)
self.assertListEqual(data, [
'ID', 'TEST_TEXT', 'TEST_INT', 'TEST_FLOAT', 'TEST_BLOB',
'TEST_DATE', 'TEST_TIME'
])
# Delete table
message_data = database.DatabaseDataMessage(
table_name="test", caller_queue=self.response_queue)
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_DELETE_TABLE,
message=message_data)
self.db_queue.put(message)
# Confirm it deleted
message_data = database.DatabaseDataMessage(
table_name="test", caller_queue=self.response_queue)
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_LIST_TABLE_COLUMNS,
message=message_data)
self.db_queue.put(message)
while self.response_queue.empty():
pass
data = self.response_queue.get()
print(data)
self.assertListEqual(data, [])
return
def tearDown(self):
self.message = database.DatabaseMessage()
self.db.kill()
self.db_queue.put(self.message)
self.db_task.join()
del (self.response_queue)
del (self.db)
del (self.db_task)
return
def ButtonCallBack(self, channel):
now = datetime.datetime.now()
print("PushButtonCallBack {} {}".format(
channel, now.strftime("%m-%d-%Y %H:%M:%S")))
# Trigger camera to take picture
self.TakePicture(channel, "push_button")
sensor_message = database.DatabaseSensorMessage(
table_name="button",
sensor_id=channel,
sensor_data=True,
date=now.strftime("%m-%d-%Y"),
time=now.strftime("%H:%M:%S"))
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_INSERT_SENSOR_DATA,
message=sensor_message)
self.db_queue.put(message)
return
def TakePicture(self, channel=None, name=None):
"""
"""
now = datetime.datetime.now()
now_string = now.strftime("%m-%d-%Y_%H-%M-%S")
filename = "images/" + name + "_" + now_string + ".jpg"
print("TakePicture {}".format(filename))
self.Camera.simple_picture(filename=filename)
self.Camera.FacialDetection(filename=filename)
image_message = database.DatabaseImageMessage(
table_name="images",
image_name=filename,
date=now.strftime("%m-%d-%Y"),
time=now.strftime("%H:%M:%S"))
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_INSERT_IMAGE_DATA,
message=image_message)
self.db_queue.put(message)
return
def run(self):
"""
Main thread loop for handling messages
"""
self.thread_running = True
twilio_response_string = "Sent from your Twilio trial account - Hello from Twilio!"
print("SMS Thread Running")
# Main loop of thread that does not end until "kill" is called and a
# message is received
while (self.thread_running):
self.message_received = False
for message in self.client.messages.list():
if message.body != twilio_response_string:
# Create the dictionary to send to the database
# which will take it back apart and store it
data_dict = {}
NOW = datetime.datetime.now()
data_dict[0] = ("SMS_TEXT",
""" "{}" """.format(message.body))
data_dict[1] = ("SMS_DATE", """ "{}" """.format(
NOW.strftime("%m-%d-%Y")))
data_dict[2] = ("SMS_TIME", """ time("{}") """.format(
NOW.strftime("%H:%M:%S")))
# Send the message to the database
db_message_data = database.DatabaseDataMessage(
table_name="sms", data_dict=data_dict)
db_message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_INSERT_DATA,
message=db_message_data)
db_queue.put(db_message)
# Wait for it to finish and delete the instances
# and structures used to send the message
db_task.join(timeout=.65)
del (db_message)
del (db_message_data)
self.client.messages.delete(message.sid)
self.message_received = True
return
def store_sms_message(self, message_from=None, message_body=None):
if message_from is None or message_body is None:
return
now = datetime.datetime.now()
db_data = {}
db_data[0] = ('SMS_FROM', """ "{}" """.format(message_from))
db_data[1] = ('SMS_TEXT', """ "{}" """.format(message_body))
db_data[2] = ('SMS_DATE',
""" "{}" """.format(now.strftime("%m-%d-%Y")))
db_data[3] = ('SMS_TIME',
"""time("{}")""".format(now.strftime("%H:%M:%S")))
print("StoreSMSMessage {}".format(db_data))
data_message = database.DatabaseDataMessage(table_name="sms",
data_dict=db_data)
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_INSERT_DATA,
message=data_message)
db_queue.put(message)
return
def get_TableData(table=None):
"""
Get all data from the specified table
"""
if table is None:
return
print("get_TableData: {}".format(table))
td_response_queue = queue.Queue()
message_data = database.DatabaseDataMessage(table_name=table,
caller_queue=td_response_queue)
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_SELECT_ALL_DATA,
message=message_data)
db_queue.put(message)
while td_response_queue.empty() is True:
pass
td_response = td_response_queue.get()
print("get_TableData: {}".format(td_response))
return td_response
def on_success(self, data):
"""
Come here when we receive a tweet with the right value
TODO: only act if from the correct user account!
"""
message = ""
user_name = ""
screen_name = ""
print(data)
if 'text' in data:
message = data['text']
if 'user' in data:
if 'name' in data['user']:
user_name = data['user']['name']
if 'screen_name' in data['user']:
screen_name = data['user']['screen_name']
data_dict = {}
NOW = datetime.datetime.now()
data_dict[0] = ("TWITTER_TEXT", """ "{}" """.format(message))
data_dict[1] = ("TWITTER_USER_NAME", """ "{}" """.format(user_name))
data_dict[2] = ("TWITTER_SCREEN_NAME",
""" "{}" """.format(screen_name))
data_dict[3] = ("TWITTER_DATE",
""" "{}" """.format(NOW.strftime("%m-%d-%Y")))
data_dict[4] = ("TWITTER_TIME",
""" time("{}") """.format(NOW.strftime("%H:%M:%S")))
db_message_data = database.DatabaseDataMessage(table_name="twitter",
data_dict=data_dict)
db_message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_INSERT_DATA,
message=db_message_data)
self.db_queue.put(db_message)
del (db_message)
del (db_message_data)
self.message_received = True
self.process_twitter_message(message)
return
def check_login(username=None, password=None):
"""
Check username and password against database to see
if user is authorized
"""
print("check_login: username=%s password=%s" % (username, password))
cl_response_queue = queue.Queue()
message_data = database.DatabaseDataMessage(
table_name="webserver",
field=""" "{}" """.format("WEBSERVER_USER_NAME"),
data=""" "{}" """.format(username),
caller_queue=cl_response_queue)
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_SELECT_DATA,
message=message_data)
db_queue.put(message)
db_task.join(timeout=0.65)
print("check_login: Wait on password response")
while cl_response_queue.empty() is True:
pass
print("check_login: Got password response")
user_response = cl_response_queue.get()
print(user_response)
# Make sure there is some sort of response before
# parsing it.
if len(user_response):
db_username = user_response[0][1]
db_password = user_response[0][2]
print("DB Username = %s" % (db_username))
print("DB Password = %s" % (db_password))
return (db_username == username and db_password == password)
else:
# There was no response so no chance of logging in or parsing
# the response
return False
SystemStateThread.start()
print("Creating Twitter Thread")
twitter_queue = queue.Queue()
twitter_task = twitter.TwitterThread(config_file=config_file,
response_queue=response_queue,
system_queue=SystemStateQueue,
db_queue=db_queue)
twitter_thread = threading.Thread(target=twitter_task.run, daemon=True)
twitter_thread.start()
print("Creating Database")
message_data = database.DatabaseDataMessage()
message_data.schema_file = "webserver_table.sql"
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_CREATE_TABLE_SCHEMA,
message=message_data)
db_queue.put(message)
print("Create SMS Table")
message_data = database.DatabaseDataMessage()
message_data.schema_file = "sms_table.sql"
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_CREATE_TABLE_SCHEMA,
message=message_data)
db_queue.put(message)
print("Create Twitter Table")
message_data = database.DatabaseDataMessage()
message_data.schema_file = "twitter_table.sql"
message = database.DatabaseMessage(
def test_DatabaseMessageDefaultValues(self):
message = database.DatabaseMessage()
self.assertIsNone(message.message)
self.assertIsNone(message.command)
return
db_queue = queue.Queue()
response_queue = queue.Queue()
sms_task = SMSReceiverThread( #config_file="/user/tractp1/.ucla.cfg",
config_file="/home/ptracton/.ucla.cfg",
response_queue=response_queue,
db_queue=db_queue)
db = database.Database(database_queue=db_queue,
database_file_name="test_sms_thread.db")
db_task = threading.Thread(target=db.run)
db_task.start()
message_data = database.DatabaseDataMessage()
message_data.schema_file = "sms_table.sql"
message = database.DatabaseMessage(
command=database.DatabaseCommand.DB_CREATE_TABLE_SCHEMA,
message=message_data)
db_queue.put(message)
db_task.join(timeout=.65)
del (message_data)
del (message)
sms_thread = threading.Thread(target=sms_task.run, daemon=True)
sms_thread.start()
#
# You need to send a text message to trigger the next step
#
last_row_id = 0
last_row = 0
