def IMEIwithSlug(self, slug):
# Initialize response
response = responses.Responses()
response.setResponse("response", False)
# Select all elements in database
allResult = database.selectLatestNElementsMongoDB(0)
# Initialize devices list and IMEIList
devicesList = []
IMEIList = []
devicesList = fetch.processDevicesList(allResult, devicesList)
# For every device in devicesList, if it's the same brand name, push into the IMEIList
for device in devicesList:
if device["Brand"] == slug:
IMEIList = device
# If IMEIList is not empty
if IMEIList:
response.setResponse("response", True)
# Set and return response
response.setResponse("devicesList", json_util.dumps(devicesList))
response.setResponse("IMEIList", json_util.dumps(IMEIList))
return response
def postRequest(self, authorization_header, resourceCalled):
# Initialize response
response = responses.Responses()
# Grub body from request
data = self.getBody()
# Grub request from body
r = self.getReq(data)
print "request: " + r
# Switch 'r' for every possible request
if r == "requestToOAuth":
response = self.fluxOrchestrator(authorization_header, data,
resourceCalled)
#response = self.requestToOAuth(authorization_header)
print "response: "
print response.getResponse()
# If we haven't a response
if not response.getResponse():
response.setResponse("response", False)
response.setResponse("Message", "Qualcosa e' andato storto")
# Return the response
return response.getResponse()
def postRequest(self, authorization_header):
# Initialize response
response = responses.Responses()
# Grub body from request
data = self.getBody()
# Grub request from body
r = self.getReq(data)
print "request: " + r
# Switch 'r' for every possible request
if r == "login":
response = self.loginProcess(data)
print "response: "
print response.getResponse()
# If we haven't a response
if not response.getResponse():
response.setResponse("response", False)
response.setResponse("Message", "Qualcosa e' andato storto")
# Return the response
return response.getResponse()
def postRequest(self):
# Initialize response
response = responses.Responses()
# Grub body from request
data = self.getBody()
# Grub request from body
r = self.getReq(data)
print "request: " + r
# Switch 'r' for every possible request
if r == "CheckMAC":
response = self.checkMAC(data)
elif r == "IfUserPayed":
response = self.pay(data)
elif r == "DeleteMAC":
response = self.deleteUser(data)
print "response: "
print response.getResponse()
# If we haven't a response
if not response.getResponse():
response.setResponse("response", False)
response.setResponse("Message", "Qualcosa e' andato storto")
# Return the response
return response.getResponse()
def fluxOrchestrator(self, authorization_header, data, resourceCalled):
#print data["u"] + " " + data["p"] + " " + data["t"]
token = data["t"]
# Initialize response
response = responses.Responses()
response.setResponse("response", False)
# Initial request if exist credentials
scope = self.requestCredentialToOAuth(authorization_header)
if scope != "ko":
#verifico se lo scope coincide
check = self.verificationScopeApplication(scope, resourceCalled)
if check == "ok":
x = self.verificationUserCredentialAndToken(data)
if x == "ok":
#check if token not expired for that client_id, client_secret
y = self.checkTokenExpiration(data["t"], scope)
print "check if token not expired for that client_id, client_secret"
print y
#NOW CHECK HERE, NOW USE THE TOKEN AS THE CURRENT TOKEN!
if y == "ok":
print "NOW CHECK HERE, NOW USE THE TOKEN AS THE CURRENT TOKEN!"
token = data["t"]
else:
token = self.requestToOAuth(authorization_header)
else:
token = self.requestToOAuth(authorization_header)
response.setResponse("response", True)
response.setResponse("key", token)
#effettuo il login
loginresult = self.loginTentativeWS1(data["u"], data["p"])
loginresult = json.loads(loginresult)
if loginresult["key"] == "ok":
response.setResponse("login", "ok")
else:
response.setResponse("login", "ko")
else:
response.setResponse("key", "invalid scope")
#save into db gateway token
database.updateCredentialAndTokenGateway(data["u"], data["p"], token)
# save into db application token
database.updateCredentialAndTokenApp(token)
print "inserito token " + token
return response
def pay(self, data):
# Initialize response
response = responses.Responses()
MAC = data["MAC"]
dbFunction = database.getMAC(MAC)
if dbFunction.count() == 0 :
response.setResponse("response", False)
else :
database.payedUser(MAC)
response.setResponse("response", True)
def AllMessagesWithIMEI(self, slug):
# Initialize response
response = responses.Responses()
response.setResponse("response", True)
# Insert into MessagesList all message for a device
response.setResponse(
"MessagesList", json_util.dumps(database.selectMessagesList(slug)))
# Return response
return response
def BrandStats(self):
response = responses.Responses()
response.setResponse("response", True)
devicesList = []
allResult = database.selectAllDevices()
devicesList = fetch.processDevicesList(allResult, devicesList)
response.setResponse("DevicesList", json_util.dumps(devicesList))
return response
def send(self, method='GET', url=None, data=None, headers=None):
session = Session()
if headers is None:
headers = self.headers
builder = Request(method,
self.base_api + url,
data=data,
headers=headers)
prepare = session.prepare_request(builder)
response = session.send(prepare)
if errors._raise_error_by_code(response.status_code):
return responses.Responses(error_code=response.status_code,
message=response.json())
else:
return responses.Responses(
code=response.json().get('meta').get('code'),
message=response.json().get('meta').get('message'),
meta=response.json().get('meta'),
data=response.json().get('data'))
def postRequest(self):
# Initialize response
response = responses.Responses()
# Grub body from request
data = self.getBody()
# Grub request from body
r = self.getReq(data)
print "request: " + r
# Switch 'r' for every possible request
if r == "InsertDevice":
response = self.InsertDevice(data)
elif r == "WebAppAllDevices":
response = self.returnAllDevices()
elif r == "GetIMEIWithSlug":
response = self.IMEIwithSlug(data["slug"])
elif r == "GetUserWithSlug":
response = self.UserWithSlug(data["slug"])
elif r == "GetAllUsers":
response = self.AllUsers()
elif r == "GetDevicesWithSlug":
response = self.DevicesWithSlug(data["slug"])
elif r == "pushMessage":
response = self.PushTheMessage(data["Message"])
elif r == "GetMessagesWithIMEI":
response = self.AllMessagesWithIMEI(data["slug"])
elif r == "GetAllDevices":
response = self.AllDevices()
elif r == "AndroidVersionStats":
response = self.AndroidVersionStats()
elif r == "BrandStats":
response = self.BrandStats()
elif r == "GetBatteryStatsWithIMEI":
response = self.BatteryStatsWithIMEI(data["slug"])
print "response: "
print response.getResponse()
# If we haven't a response
if not response.getResponse():
response.setResponse("reponse", False)
response.setResponse("Message", "Qualcosa e' andato storto")
# Return the response
return response.getResponse()
def DevicesWithSlug(self, IMEI):
# Initialize response
response = responses.Responses()
response.setResponse("response", False)
# Select all info for a device with selected IMEI
allResult = json_util.dumps(database.selectDevicesWithSlug(IMEI))
# If device exist
if allResult:
response.setResponse("response", True)
response.setResponse("DevicesList", allResult)
# Return response
return response
def checkMAC(self,data):
# Initialize response
response = responses.Responses()
MAC = data["MAC"]
dbFunction = database.getMAC(MAC)
if dbFunction.count() == 0 :
key = self.createKey()
database.insertElementMongoDB({"MAC": MAC,"key": key,"payed": False})
response.setResponse("response", False)
response.setResponse("key",key)
else:
response.setResponse("response", True)
response.setResponse("key", dbFunction[0]["key"])
response.setResponse("payed", dbFunction[0]["payed"])
return response
def AllDevices(self):
# Initialize response
response = responses.Responses()
response.setResponse("response", True)
# Select all devices into database
allResult = database.selectAllDevices()
# Initialize devices list
devicesList = []
# Select and map only physical devices (without duplicate entry)
map(lambda x: fetch.mapIMEIinDevice(devicesList, x), allResult)
# Set and return response
response.setResponse("DevicesList", json_util.dumps(devicesList))
return response
def AllUsers(self):
# Initialize response
response = responses.Responses()
response.setResponse("response", False)
# How many thread
NUM_WORKERS = 4
# Create a Queue
task_queue = Queue()
# Create a Lock
tLock = Lock()
# Initialize user list
userList = []
# Select all users
tmpResult = database.selectAllUsers()
# for each tmpResult, create a thread
threads = [
Thread(target=self.worker, args=(tLock, task_queue, userList))
for _ in range(NUM_WORKERS)
]
# Add the username to the task queue
[task_queue.put(user["UserInfo"]["Username"]) for user in tmpResult]
# Start all the workers
[thread.start() for thread in threads]
# Wait for all the tasks in the queue to be processed
task_queue.join()
# If userList is not empty
if json_util.dumps(userList):
response.setResponse("response", True)
# Set and return response
response.setResponse("UserList", json_util.dumps(userList))
return response
def InsertDevice(self, data):
# Initialize response
response = responses.Responses()
# Add timestamp before fetching
data["date"] = datetime.datetime.now()
# Insert device into database
result = database.insertElementMongoDB(data)
# Save id into log file
strReturn = 'Successfully inserted, with ID: {0}'.format(
result.inserted_id)
logs.saveLog("request.py", strReturn)
# Set and return success message
response.setResponse("response", True)
response.setResponse("Message", "Successfully inserted")
return response
def __init__(self, config):
if not hasattr(config, 'cli'):
args = (config.nick, config.ident, config.realname,
config.chanlist, config.nspassword)
irc.Bot.__init__(self, *args)
self.uptime = 0
self.stack = [0]
self.config = config
self.nick = self.config.nick
self.waitfactor = self.config.waitfactor
self.cooldowntime = self.config.cooldowntime
self.freespeech = self.config.freespeech
self.starttime = time.time()
self.admins = self.config.admins
self.connected = False
self.cooldown = False
self.kicked = False
self.responses = responses.Responses()
self.setup()
def BatteryStatsWithIMEI(self, slug):
# Initialize response
response = responses.Responses()
response.setResponse("response", True)
# Initialize lists
allResp = []
h = []
# Select all from database for that device
tmpResult = database.selectDevicesWithSlug(slug)
# Initialize allResp list with hours document
for x in xrange(0, 23):
if x < 10:
allResp.append({
"value": "0" + str(x),
"counter": 0,
"battery": 0
})
else:
allResp.append({"value": str(x), "counter": 0, "battery": 0})
# For every device in database, for every hour, if we have some battery usage for today, fill hour list
for device in tmpResult:
for hour in allResp:
# se il documento rientra nelle ultime 24 ore
if (fetch.getHourByDate(str(device["date"]))
== hour["value"]) and hour["counter"] < 1 and (
fetch.todayDay(device["date"])):
hour["counter"] += 1
hour["battery"] = device["BatteryInfo"]["Level"]
h.append(hour["battery"])
# If we had battery usage
if h:
response.setResponse("all", h)
# Return response
return response
def AndroidVersionStats(self):
# Initialize response
response = responses.Responses()
response.setResponse("response", True)
# Initialize devices list
devicesList = []
# Select all result from database
allResult = database.selectAllDevices()
# For every device in database, if devicesList is empty or don't contain that Android version, push that device
# in new brand document first and then in devicesList, else push that Android version in correct brand document
# first and then in devicesList
for device in allResult:
if (not devicesList) or (not filter(
lambda x: x["AndroidVersion"] == fetch.getAndroidVersion(
device), devicesList)):
devicesList.append({
"AndroidVersion":
fetch.getAndroidVersion(device),
"IMEI": [device["TelephoneInfo"]["IMEI"]],
"counter":
1
})
else:
map(
lambda x: x["IMEI"].append(device["TelephoneInfo"][
"IMEI"]), (filter(
lambda x: (x["AndroidVersion"] == fetch.
getAndroidVersion(device)) and
(not device["TelephoneInfo"]["IMEI"] in x["IMEI"]),
devicesList)))
for device in devicesList:
device["counter"] = len(device["IMEI"])
# Set and return response
response.setResponse("AndroidVersionList",
json_util.dumps(devicesList))
return response
def returnAllDevices(self):
# Initialize response
response = responses.Responses()
response.setResponse("response", False)
# Select all elements in database
allResult = database.selectLatestNElementsMongoDB(0)
# Initialize devices list
devicesList = []
devicesList = fetch.processDevicesList(allResult, devicesList)
# Set True response if devicesList is not empty
if devicesList:
response.setResponse("response", True)
# Set and return response
response.setResponse("devicesList", json_util.dumps(devicesList))
return response
def loginProcess(self, data):
# Initialize response
response = responses.Responses()
username = data["username"]
password = data["password"]
x = database.selectCredential()
#fetch database data in order to check if theres something
#if yes, return ok
#if not, return ko
if x == "ok":
response.setResponse("response", True)
response.setResponse("key", "ok")
else:
response.setResponse("response", False)
response.setResponse("key", "ko")
return response
def UserWithSlug(self, slug):
# Initialize response
response = responses.Responses()
response.setResponse("response", False)
# Initialize devices list
userList = []
# Select all users with those slug in database
allResult = database.selectUserWithSlug(slug)
# Select and map only physical devices (without duplicate entry)
map(lambda x: fetch.mapIMEIinDevice(userList, x), allResult)
# If userList is not empty
if json_util.dumps(userList):
response.setResponse("response", True)
# Set and return response
response.setResponse("UserList", json_util.dumps(userList))
return response
def PushTheMessage(self, message):
# Initialize response
response = responses.Responses()
response.setResponse("response", True)
# Create new message 'm' with all field setted
m = messages.Messages(message["Username"], message["Sender"],
message["ReceiverNumber"], message["Text"],
message["IMEI"])
# Convert 'm' object into JSON
messageList = m.createJson()
# Insert the message into database
database.insertMessageList(messageList)
# Just for debug
print m.getSender() + " ha inviato a " + m.getReceiver(
) + ": " + m.getText()
# Return response
return response
def requestToOAuth(self, authorization_header):
# Initialize response
response = responses.Responses()
#Initial request if exist credentials
scope = self.requestCredentialToOAuth(authorization_header)
if scope != "ko":
"""
#request for auth code
code = self.requestForOAuthCode(authorization_header)
#request for auth token
test = self.requestForGrantOAuth(code)
if test == "ok":
result = self.requestForAuthorization(authorization_header)
token = self.requestForTokenOAuth(authorization_header, result)
else:
token = "error with token"
"""
result = self.requestForAuthorization(authorization_header)
token = self.requestForTokenOAuth(authorization_header, result,
scope)
response.setResponse("response", True)
response.setResponse("key", token)
else:
token = "None"
response.setResponse("response", False)
response.setResponse("key", "some errors occurred")
#return response
return token
from datetime import datetime, timedelta
import schedule
import reminderStore
import responses
import static_variables
# standard app engine imports
from google.appengine.api import urlfetch
from google.appengine.ext import ndb
import webapp2
# Glowne zmienne
plan = schedule.Schedule() # Obsluga planu
reminder = reminderStore # Obsluga przypomnien
response = responses.Responses()
#facebook = facebook_utils.Facebook() # Obsluga facebooka
luck_level = 2 # W przedziale od 0 do 100 im wiecej tym czesciej glupie odpowiedzi
#warnings.filterwarnings('ignore', category=DeprecationWarning) # Ignorowanie bledow o przestarzalych funkcjach - do facebooka
# Token telegrama
TOKEN = '129060792:AAGFH7v-zyS-PfX1I_-FOSIvm6vAAH9Yi-U'
BASE_URL = 'https://api.telegram.org/bot' + TOKEN + '/'
def luck_sim(msg):
luck = random.randint(0, 100)
if luck > luck_level:
return msg
else:
def __call__(cls, *args, **kwargs): f = type.__call__(cls, *args, **kwargs) f.handlers = HandlerAccess(f) f.listeners = f.listeners.copy() f.responses = responses.Responses(f, f.responses) return f
import registered_users as ru
import responses as resp
import config as conf
import smtplib, ssl
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
config = conf.Config()
users = ru.RegisteredUsers(config)
responses = resp.Responses(config, users)
def create_email(user_id, email, firstname, lastname):
msg = MIMEMultipart('alternative')
msg['Subject'] = "T'es là?"
msg['From'] = "tesla"
msg['To'] = email
url = config.get_config('index_url')
urlid = url + '?id=' + str(user_id)
urlyes = urlid + '&q=respond&resp=yes'
urlno = urlid + '&q=respond&resp=no'
text = "Salut " + firstname + "!\nT'es là aujourd'hui?"
text += "\n"
text += "Oui: " + urlyes + "\n"
text += "Non: " + urlno + "\n"
text += "\n"
text += "Oui jusqu'à la fin de la semaine: " + urlyes + "&validity=next_monday\n"
class Handler(http.server.BaseHTTPRequestHandler):
config = conf
users = ru.RegisteredUsers(config)
responses = resp.Responses(config, users)
# def __init__(self):
# print("Initializing server")
@staticmethod
def remove_html(s):
tags = re.compile('<.*?>')
return re.sub(tags, '', s)
@staticmethod
def extract_value(query, name, required=False):
if name in query:
return Handler.remove_html(query[name][0])
elif not required:
return None
else:
raise ValueError
def respond_raw(self, code, data):
datastr = json.dumps(data, ensure_ascii=False)
print("ERROR ", code)
self.send_response(code, code)
self.send_header("Content-type", 'text/json; charset=utf-8')
self.send_header('Access-Control-Allow-Origin', '*')
self.end_headers()
self.wfile.write(datastr.encode('utf-8'))
print("Response ({}): ".format(datastr).encode('utf-8'))
return code
def respond_with_message(self, query_type, msg, msg_type=1):
d = {
'resp_type': query_type,
'subtype': 'message',
'msg_string': msg,
'message_type': msg_type
}
self.respond_raw(200, d)
self.log_error('MESSAGE %s: %s', str(200), msg)
return 200
def respond_with_error(self, query_type, msg):
self.log_error('ERROR')
self.respond_with_message(query_type, msg, -1)
def respond_with_parse_error(self, query_type, q):
msg = "Error: cannot parse query: '" + q + "'"
return self.respond_with_error(query_type, msg)
def respond_with_data(self, query_type, data):
d = {'resp_type': query_type, 'subtype': 'data', 'data': data}
self.log_error('RESPOND WITH DATA %s', str(data))
self.respond_raw(200, d)
def respond_with_userinfo(self, id, firstname, lastname, email):
self.respond_with_data('userinfo', {
'id': id,
'firstname': firstname,
'lastname': lastname,
'email': email
})
def respond_with_list(self, data):
self.respond_with_data('list', data)
def respond_with_register_success(self, id, msg):
self.respond_with_data('register', {'id': id, 'msg_string': msg})
def get_delay_from_validity(self, validity):
if validity != None:
if validity == 'next_monday' or validity == 'next_moday':
today = date.today()
delay = timedelta(days=-today.weekday() - 1, weeks=1)
return delay
elif validity.isdigit():
d = int(validity)
if (d > 10):
self.respond_with_message("response", "Non.", 0)
raise IndexError
delay = timedelta(days=d)
return delay
raise ValueError
def process_query_response(self, qs, query):
try:
id = self.extract_value(query, 'id')
resp = self.extract_value(query, 'resp', required=True)
validity = self.extract_value(query, 'validity')
except ValueError:
self.respond_with_parse_error('response', qs)
raise ValueError
user = self.users.get_user_from_id(id)
if id != None and user != None:
try:
if resp == 'no_spam':
if validity != None:
self.users.set_no_spam(
id, self.get_delay_from_validity(validity))
else:
raise ValueError
elif resp == 'yes' or resp == 'no':
if validity == None:
self.responses.update_response(id, resp == 'yes')
else:
self.responses.update_response(id, resp == 'yes')
self.users.set_long_response(
id, resp == 'yes',
self.get_delay_from_validity(validity))
else:
raise ValueError
except ValueError:
self.respond_with_parse_error('response', qs)
raise ValueError
self.respond_with_data("response", {'msg_string': "C'est noté."})
else:
self.respond_with_message(
"response",
"Identifiant inconnu ou non renseigné. Il faut s'inscrire pour pouvoir voir ce que font les autres.",
0)
def process_query_userinfo(self, qs, query):
id = None
id = self.extract_value(query, 'id')
if id == None or not self.users.has_registered(id):
self.respond_with_message('userinfo',
'Utilisateur inconnu : ' + id, 0)
raise ValueError
u = self.users.get_user_from_id(id)
self.respond_with_userinfo(id, u['firstname'], u['lastname'],
u['email'])
def process_query_register(self, qs, query):
id = None
email = None
id = self.extract_value(query, 'id')
email = self.extract_value(query, 'email')
firstname = self.extract_value(query, 'firstname')
lastname = self.extract_value(query, 'lastname')
remove = self.extract_value(query, 'remove')
if email and firstname and lastname:
# TODO test if someone with this email exists
if not id:
id = self.users.add_user(email, firstname, lastname)
self.respond_with_register_success(
id, "Salut {}, t'as bien été ajouté(e).".format(firstname))
else:
if self.users.has_registered(id):
self.users.update_user(id, email, firstname, lastname)
self.respond_with_register_success(
id, "Salut {}, tes infos ont bien été mises à jour.".
format(firstname))
else:
self.respond_with_message(
'register',
"T'es pas dans la base, {}.".format(firstname), 0)
else:
self.respond_with_parse_error('register', qs)
def respond_with_register_success(self, id, msg):
self.respond_with_data('register', {'id': id, 'msg_string': msg})
def process_query_userinfo(self, qs, query):
id = None
id = self.extract_value(query, 'id')
if id == None or not self.users.has_registered(id):
self.respond_with_message('userinfo',
'Utilisateur inconnu : ' + id, 0)
raise ValueError
u = self.users.get_user_from_id(id)
self.respond_with_userinfo(id, u['firstname'], u['lastname'],
u['email'])
def process_query_sendemail(self, qs, query):
email = self.extract_value(query, 'email')
id = None
try:
id = self.users.get_id_from_email(email)
except KeyError:
self.respond_with_message('sendemail', "Email inconnu.")
return
user = self.users.get_user_from_id(id)
se.send_mail(
user['email'],
se.create_email(id, user['email'], user['firstname'],
user['lastname']))
self.respond_with_message('sendemail', "Email envoyé.")
def process_query_list(self, qs, query):
id = None
id = self.extract_value(query, 'id')
if id == None or not self.users.has_registered(id):
self.respond_with_message(
'list',
"T'es pas inscrit(e), tu peux pas voir ce que font les autres.",
0)
elif not self.responses.has_responded(id):
self.respond_with_message(
'list',
"T'as pas répondu aujourd'hui, tu peux pas voir ce que font les autres.",
0)
else:
resp_list = []
resp = self.responses.get_list()
# todo join
for uid in resp.keys():
u = self.users.get_user_from_id(uid)
if u != None:
resp_list.append({
'firstname': u['firstname'],
'lastname': u['lastname'],
'resp': resp[uid]
})
self.respond_with_list(resp_list)
def process_query_remove(self, qs, query):
id = self.extract_value(query, 'id')
if id != None:
self.users.remove_user(id)
self.respond_with_data('remove', {"msg_string": 'Supprimé(e)'})
else:
self.respond_with_message('remove', "Id inconnu", 0)
def do_GET(self):
req = urlparse(self.path)
query = None
qs = req.query
try:
query = parse_qs(qs, strict_parsing=True)
except ValueError as e:
self.respond_with_parse_error('-', qs)
raise ValueError
print("Received Query:", qs)
q = self.extract_value(query, 'q')
print("query type", q)
if q == 'userinfo':
self.process_query_userinfo(qs, query)
elif q == 'list':
self.process_query_list(qs, query)
elif q == 'respond' or q == 'response':
self.process_query_response(qs, query)
elif q == 'register':
self.process_query_register(qs, query)
elif q == 'sendemail':
self.process_query_sendemail(qs, query)
elif q == 'remove':
self.process_query_remove(qs, query)
else:
# default,
self.process_query_list(qs, query)
# self.respond_with_parse_error('-', qs)
# raise ValueError
return 0
