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