def save_account(self, username, password):
consolelog.log(LOG_TITLE, "Saving email account")
self.save_to_file({
self.gmail_username: username,
self.gmail_password: password
})
return True
def on_message(self, ws, message):
self.set_status("ok")
consolelog.log(LOG_TITLE, "msg - > %s" % message)
message = json.loads(message)
if (message['type'] == "tickle"):
self.fetch_pushes(self.last_timestamp)
self.getToken() #For check change token
def run(self):
self.status = SmsStatus.SENDING
self.status_callback(self.status)
consolelog.log(LOG_TITLE, "thread started")
self.config()
try:
#command_string = 'sudo gammu sendsms TEXT ' + self.sms_number + ' -textutf8 "' + self.sms_message + '" '
#print commands.getoutput(command_string)
self.status = SmsStatus.ERROR
sm = gammu.StateMachine()
sm.ReadConfig()
sm.Init()
message = {
'Text': self.sms_message,
'SMSC': {
'Location': 1
},
'Number': self.sms_number,
}
# Actually send the message
result = sm.SendSMS(message)
consolelog.log(LOG_TITLE, "Send sms Success")
self.status = SmsStatus.SUCCESS
except gammu.ERR_DEVICENOTEXIST:
consolelog.log(LOG_TITLE, "Error device doesn't exist")
self.status = SmsStatus.ERR_DEVICENOTEXIST
except gammu.ERR_NOSIM:
consolelog.log(LOG_TITLE, "Error can not access SIM card")
self.status = SmsStatus.ERR_NOSIM
except ValueError:
consolelog.log(LOG_TITLE, "Error")
self.status = SmsStatus.ERROR
self.status_callback(self.status)
def run(self):
self.set_flag(True)
start = time.time()
consolelog.log(LOG_TITLE, "Saying " + self.phrase)
os.system("echo \"" + self.phrase + "\" | festival --tts")
end = time.time() - start
consolelog.log(LOG_TITLE, "time used %f s" % end)
self.set_flag(False)
def __init__(self, gogod_config=None):
consolelog.log(LOG_TITLE, "init")
self.conf = config.Config() if gogod_config is None else gogod_config
self.running_list = {}
self.reserved_name = [
'__init__.py', 'checker.py', 'gogod_interface.py', 'example.py',
'example_with_variable.py'
]
self.autorun()
def __init__(self, gogod_config=None):
self.last_handle_time = 0
self.conf = config.Config() if gogod_config is None else gogod_config
self.api_key = self.conf.get_iftt_key()
self.event_name = None
self.dict_data = None
self.limit_check = rate_limit_checker.RateLimitChecker(
_rate_limit_ifttt)
consolelog.log(LOG_TITLE, "Created Class")
def run(self):
""" Method that runs forever """
consolelog.log(LOG_TITLE, "background started")
while True:
# Do something
# print('Status : ' + self.status)
if (self.status == "none"):
self.new_ws_connection()
elif (self.status == "close"):
self.new_ws_connection()
time.sleep(self.interval)
def run(self):
# self.token = "m3b2ydsSGqkq9meRZAgbKoE0PmSXQqAB"
self.getToken()
if self.is_valid_token(self.token):
self.fetch_pushes()
global flag_run
if ((flag_run == False) and (self.token is not None)):
consolelog.log(LOG_TITLE, "starting")
self.connect()
def __init__(self, gogod_config=None, sendKeyValue=None):
global _latest_sender_id
self.last_handle_time = 0
self.conf = config.Config() if gogod_config is None else gogod_config
self.sendKeyValue = sendKeyValue
self.token = self.conf.get_telegram_bot_token()
_latest_sender_id = self.get_sender()
consolelog.log(LOG_TITLE, "Created Class")
self.connect()
thread = threading.Thread(target=self.run, args=())
thread.daemon = True # Daemonize thread
thread.start() # Start the execution
def config(self):
if not os.path.exists(GAMMU_CONFIG_FILE):
consolelog.log(LOG_TITLE, "No gammu config File")
gammu_config_content = '''[gammu]
port = /dev/ttyUSB0
model =
connection = at19200
synchronizetime = yes
logfile =
logformat = nothing
use_locking =
gammuloc =
'''
file = open(GAMMU_CONFIG_FILE, "w+")
file.write(gammu_config_content)
file.close()
consolelog.log(LOG_TITLE, "Written config to file")
if 'DefaultVendor' not in open(USB_CONFIG_FILE).read():
consolelog.log(LOG_TITLE, "No Device config")
modeswitch_content = '''DefaultVendor= 0x12d1
DefaultProduct = 0x1446
TargetVendor = 0x12d1
TargetProductList ="1001,1406,140b,140c,141b,14ac"
CheckSuccess = 20
MessageContent ="55534243123456780000000000000011060000000000000000000000000000"'''
file = open(USB_CONFIG_FILE, 'a')
file.write(modeswitch_content)
file.close()
consolelog.log(LOG_TITLE, "Written device config")
os.system("sudo usb_modeswitch -c /etc/usb_modeswitch.conf")
def init_mqtt_client(self):
MQTT_USER = self.uid
MQTT_CLIENT_ID = self.uid
if (self.mqtt_client is not None and self.mqtt_client.is_connected):
if self.mqtt_client.username != MQTT_USER:
consolelog.log(LOG_TITLE, "MQTT disconnect the exists")
self.mqtt_client.disconnect()
else:
consolelog.log(LOG_TITLE, "MQTT keep the exists")
return
self.mqtt_client = mqtt.Client(MQTT_CLIENT_ID)
self.mqtt_client.username_pw_set(MQTT_USER, MQTT_PASSWORD)
self.mqtt_client.on_connect = mqtt_on_connect
self.mqtt_client.on_disconnect = mqtt_on_disconnect
self.mqtt_client.is_connected = False
self.mqtt_client.is_connecting = True
self.mqtt_client.username = MQTT_USER
global LAST_CONNECT
LAST_CONNECT = time.time()
# mqtt_client.on_message = on_message
consolelog.log(LOG_TITLE, "MQTT connecting")
try:
self.mqtt_client.connect(MQTT_ADDRESS, port=1883, keepalive=10)
except Exception as e:
print(e)
consolelog.log(LOG_TITLE, "MQTT connect error")
time.sleep(0.1)
def list_files(self):
library_list = []
for f in os.listdir(os.path.abspath(ADDONS_PATH)):
module_name, ext = os.path.splitext(
f) # Handles no-extension files, etc.
if ext == '.py': # Important, ignore .pyc/other files.
consolelog.log(LOG_TITLE, 'found %s' % (module_name))
# module = __import__(module_name)
library_list.append("%s%s" % (module_name, ext))
return list(
set(library_list) -
(set(self.reserved_name) -
set(['example.py', 'example_with_variable.py'])))
def __init__(self, gogod_config=None):
threading.Thread.__init__(self)
self.state_normal = False # False = queue, True = normal
self.conf = config.Config() if gogod_config is None else gogod_config
self._last_handle = {}
self.data_to_update = {}
self.uid = self.conf.get('datalog_uid')
self.mqtt_client = None
self.is_connected = False
self.is_connecting = True
consolelog.log(LOG_TITLE, "Created Thread ")
self.start()
def get_queue_file(self):
return_data = None
if os.path.exists(QUEUE_FILE):
with open(QUEUE_FILE, 'r') as f:
data = f.readline()
if data == '':
return return_data
io_string = StringIO(data)
try:
return json.load(io_string)
except:
# if invalid
self.pop_queue_file()
consolelog.log(LOG_TITLE, "Queue file error")
return return_data
def publish(self, data):
if self.uid is None or self.uid == '':
return
if self.mqtt_client is None:
self.init_mqtt_client()
elif not self.mqtt_client.is_connected and not self.mqtt_client.is_connecting:
self.init_mqtt_client()
if self.mqtt_client.is_connected:
consolelog.log(LOG_TITLE, data)
self.mqtt_client.publish(
"log/%s/%s" % (data["user"], data["field"]),
"%s %s=%s" % (data["user"], data["field"], data["value"]))
global LAST_CONNECT
LAST_CONNECT = time.time()
def pub_publish(self, data):
# uid = self.uid
if self.uid is None or self.uid == '':
# uid = data["channel"]
self.uid = data["channel"] + self.random_string()
if self.mqtt_client is None:
self.init_mqtt_client()
elif not self.mqtt_client.is_connected and not self.mqtt_client.is_connecting:
self.init_mqtt_client()
if self.mqtt_client.is_connected:
consolelog.log(LOG_TITLE, data)
self.mqtt_client.publish(
"plog/%s/%s" % (data["channel"], data["field"]),
"%s %s=%s" % (data["channel"], data["field"], data["value"]))
global LAST_CONNECT
LAST_CONNECT = time.time()
def save_to_file(self, params):
if self.status_callback is not None and (self.gmail_username in params
or self.gmail_password
in params):
self.status_callback(10 + self.EmailStatus.CONNECTING)
data = {}
if os.path.exists(CONFIG_FILE):
jsonFile = open(CONFIG_FILE, "r")
data = json.load(jsonFile)
jsonFile.close()
for key, value in params.iteritems():
if not self.is_valid_config_name(key):
continue
if key == self.gmail_password:
value = None if value == "None" else value
data[key] = self.enc.EncodeAES(value)
else:
data[key] = value
self.current[key] = value
jsonFile = open(CONFIG_FILE, "w+")
jsonFile.write(json.dumps(data))
jsonFile.close()
# Backup old account
# if (os.path.exists(self.ENCRYPT_FILE)):
# os.rename(self.ENCRYPT_FILE, self.ENCRYPT_FILE+".bak")
# file = open(self.ENCRYPT_FILE, "w")
# file.write(param.username + "\n")
# file.write(self.encrypt(self.ENCRYPT_PASSWORD, param.password) + "\n")
# file.close()
consolelog.log(LOG_TITLE, "Saved")
if self.status_callback is not None:
self.status_callback(10 + self.EmailStatus.SUCCESS)
def __init__(self, gogod_config=None):
threading.Thread.__init__(self)
self.data_to_update = {}
self.data_from_queue = {}
self.last_handle = 0
self.count = 0
self.state_normal = False # False = queue, True = normal
self.queue_not_upload = Queue.Queue()
self.flag_connect = False
self.conf = config.Config() if gogod_config is None else gogod_config
self.api_key = self.conf.getClouddataKey()
self._last_handle = {'field1': 0}
self.valid_names = [
'field1', 'field2', 'field3', 'field4', 'field5', 'field6',
'field7', 'field8', 'created_at'
]
consolelog.log(LOG_TITLE, "Created Thread")
self.start()
def fetch_pushes(self, timestamp=1429750800):
request = urllib2.Request(
"https://api.pushbullet.com/v2/pushes?modified_after=%s" %
timestamp)
request.add_header("Authorization", "Bearer %s" % self.token)
try:
result = urllib2.urlopen(request)
json_data = result.read()
self.last_timestamp = time.time()
data = json.loads(json_data)
#print data
if 'pushes' in data:
for entry in data['pushes']:
if (not entry['dismissed']):
if (len(entry['title'].split(' ')) == 1):
self.callback_setKeyValueEvent(
entry['title'], entry['body'])
# print data
except:
consolelog.log(LOG_TITLE, "Fetch Error")
def run(self):
global _latest_sender_id, _bot, _last_worked_token
self.bot = telepot.Bot(self.token)
if self.token in _connected_token:
consolelog.log(LOG_TITLE, "already connected")
return
try:
self.bot.getMe()
self.is_connected = True
_connected_token.append(self.token)
_bot = self.bot
_last_worked_token = self.token
consolelog.log(LOG_TITLE, "Connected")
except:
self.bot = None
self.is_connected = False
consolelog.log(LOG_TITLE, "Invalid token")
return
self.bot.message_loop({'chat': self.on_telegram_message})
self.send_telegram_message('Hello, I woke up.')
while(True):
if self.stopped():
return
time.sleep(1)
def upload_file(self, params):
result = {'result': False}
confirm = params['confirm'] == 'true'
filename = self.corect_filename(params['file']['filename'])
full_file_path = os.path.join(ADDONS_PATH, filename)
consolelog.log(LOG_TITLE, 'file named %s' % filename)
#Check is a reserved name
if filename in self.reserved_name:
result['message'] = 'file_reserved'
consolelog.log(LOG_TITLE, 'file reserved')
return result
# Check file exists?
result['message'] = (os.path.exists(full_file_path))
if result['message'] and not confirm:
result['message'] = 'file_exists'
consolelog.log(LOG_TITLE, 'file exists')
return result
# Write html content to a file.
htmlFile = open(full_file_path, "w+")
htmlFile.write(params['file']['body'])
htmlFile.close()
result['result'] = True
return result
def checkdo(self):
threading.Timer(1.0, self.checkdo).start()
self.count += 1
self.state_normal = False
# Checking the exist queue first
if self.count <= 1:
if self.data_from_queue == {}:
queue_data = self.get_queue_file()
queue_data = self.check_valid_name(queue_data)
if queue_data is not None and queue_data != {}:
self.data_from_queue = queue_data
else:
self.pop_queue_file()
else:
self.state_normal = True
if self.data_from_queue != {}:
consolelog.log(LOG_TITLE, "Queueing")
# if send data success then clear variable
if self.updateData(self.data_from_queue):
self.data_from_queue = {}
self.pop_queue_file()
if (self.count > 1 or self.state_normal) and self.data_to_update != {}:
#elif self.data_to_update != {} :
self.count = 0
if not self.updateData(self.data_to_update):
self.onFail()
self.addToQueue(self.data_to_update)
self.clearData()
elif self.data_to_update == {}:
self.count = 0
if self.count >= 4:
self.count = 0
def on_telegram_message(self, msg):
global _latest_sender_id
content_type, chat_type, chat_id = telepot.glance(msg)
message = msg['text']
if self.latest_sender_id != chat_id:
self.latest_sender_id = chat_id
_latest_sender_id = chat_id
self.save_sender(chat_id)
if self.bot is None:
return
for str in ['ping', 'echo']:
if message.startswith(str):
message = re.sub(str,'',message,1)
self.bot.sendMessage(chat_id, message.strip())
break
consolelog.log(LOG_TITLE, "message : %s" % message)
if self.sendKeyValue is not None:
self.sendKeyValue("telegram", message)
def start_addons(self, filename):
result = {'result': False, 'error': ''}
consolelog.log(LOG_TITLE, 'Starting %s' % filename)
# check is already run
if filename in self.running_list:
result['error'] = 'Already Run'
consolelog.log(LOG_TITLE, '%s already run' % filename)
return result
# Verify the file syntax
file_verify = self.verify(filename)
if not file_verify['result']:
consolelog.log(LOG_TITLE, 'verify %s fail' % filename)
return file_verify
full_filepath = os.path.join(ADDONS_PATH, filename)
cmd = 'python %s' % full_filepath
result_testrun = self.testrun(cmd)
# Verify the file
if not result_testrun['result']:
return result_testrun
pro = subprocess.Popen(cmd.split(),
stdout=subprocess.PIPE,
shell=False,
preexec_fn=os.setsid)
# out, err = pro.communicate()
# result['message'] = out
# result['error'] = err
# result['result'] = (err == '')
result['result'] = True
if result['result']:
self.running_list[filename] = pro
# else:
# os.killpg(os.getpgid(pro.pid), signal.SIGTERM) # Send the signal to all the process groups
consolelog.log(LOG_TITLE,
'Started %s %s' % (filename, result['result']))
return result
def getToken(self):
token = self.conf.getPushbulletToken()
# print token
if ((self.token is not None) and (self.token != token)):
consolelog.log(LOG_TITLE, "Token changed by user")
self.set_status("close")
self.ws.close()
self.stop()
if ((self.token != token) and self.is_valid_token(token)):
self.token = token
consolelog.log(LOG_TITLE, "Changed token")
elif ((self.token != token) and self.token is not None
and not self.is_valid_token(token)):
consolelog.log(LOG_TITLE, "Invalid token file")
def makeWebRequest(self, event_name=None, dict_data=None):
self.getAPIKey()
if event_name is None or self.api_key is None:
return False
#self.flag_connect = True
consolelog.log(LOG_TITLE, event_name)
consolelog.log(LOG_TITLE, dict_data)
url = "https://maker.ifttt.com/trigger/%s/with/key/%s" % (event_name,
self.api_key)
try:
r = requests.post(url, data=dict_data)
return_data = r.text
self.last_handle_time = time.time()
consolelog.log(LOG_TITLE, return_data)
#self.flag_connect = False
return True
except:
consolelog.log(LOG_TITLE, "Connected Error")
#self.flag_connect = False
return False
return False
def stop_addons(self, filename):
result = {'result': True}
if filename in self.running_list:
consolelog.log(LOG_TITLE, 'Terminating %s' % filename)
pro = self.running_list[filename]
os.killpg(
os.getpgid(pro.pid),
signal.SIGTERM) # Send the signal to all the process groups
del self.running_list[filename]
result['result'] = True
consolelog.log(LOG_TITLE, 'Terminated %s' % filename)
else:
consolelog.log(LOG_TITLE, ' %s is not run' % filename)
return result
def send_telegram_photo(self, filename):
global _latest_sender_id, _bot, _last_worked_token
if _latest_sender_id is None or _bot is None:
return
filepath = self.conf.auto_filepath_image(filename)
if not os.path.exists(filepath):
return
consolelog.log(LOG_TITLE, 'sending image')
url = 'https://api.telegram.org/bot%s/sendPhoto' % _last_worked_token
files = {'photo': open(filepath, 'rb')}
data = {'chat_id': _latest_sender_id,'caption':filename}
try:
r = requests.post(url, data=data, files=files)
consolelog.log(LOG_TITLE, 'sent result %s' % r.json()['ok'])
except:
consolelog.log(LOG_TITLE, 'sent image fail')
def updateData(self, dictData):
#if self.flag_connect:
# return False
#self.flag_connect = True
dictData = self.check_valid_name(dictData)
consolelog.log(LOG_TITLE, "%s" % dictData)
self.getAPIKey()
if not self.conf.validateClouddataKey(self.api_key):
return False
if dictData is None or dictData == {}:
return True
data = copy.deepcopy(dictData)
data['key'] = self.api_key
params = urllib.urlencode(dictData)
request = urllib2.Request(
"https://data.learninginventions.org/update?key=%s&%s" %
(self.api_key, params))
try:
# r = requests.post("https://data.learninginventions.org/update", data=data, ,verify=False)
# return_data = r.text
result = urllib2.urlopen(request)
return_data = result.read()
self.last_timestamp = time.time()
consolelog.log(LOG_TITLE, "Seq. =%s" % return_data)
#self.flag_connect = False
#return int(return_data) > -1
return True
except:
consolelog.log(LOG_TITLE, "Connected Error")
#self.flag_connect = False
return False
return False
def send(status_callback, sms_number, sms_message):
consolelog.log(LOG_TITLE, "starting sms thread")
sms_thread = SmsHandle(status_callback, sms_number, sms_message)
sms_thread.start()
