def __send_to_ios(self, message): payload = Payload(alert=message, sound="default", badge=1) apns = APNs(use_sandbox=True, cert_file=Config.get('user_pushes.ios_cert_path'), key_file=Config.get('user_pushes.ios_key_password')) apns.gateway_server.send_notification(self.__push_token, payload)
def __send_to_android(self, message, title, data): data = self.__get_formatted_android(message, title, data) headers = {'Content-Type': 'application/json', 'Authorization': 'key=' + Config.get('user_pushes.android_key')} try: # response format: {'success': 1, 'results': [{'message_id': '0:1484578305084796%cecede4ccecede4c'}], 'canonical_ids': 0, 'failure': 0, 'multicast_id': 4756401486043037727} response = requests.post(Config.get('user_pushes.android_server'), data=data, headers=headers).json() except: pass
def __get_home_screen(self): user = self.get_user() users_list = [] # user's favourites favorites = Favorite.where_has('favorite', lambda q: q.where('user_id', '=', user.id)) \ .limit(Config.get('home_screen.favourite_limit')) \ .order_by('id', 'desc') \ .get() for fav in favorites: formatted_user = fav.favorite.format_list() formatted_user['last_message'] = {} formatted_user['favorite'] = True users_list.append(formatted_user) # last connections - last message to user or from user messages = Message.where({'id_from': user.id}) \ .or_where({'id_to_user': user.id}) \ .where_null('id_to_chat') \ .order_by('created_at', 'desc') \ .limit(Config.get('home_screen.last_connections_limit')) \ .get() for message in messages: if str(message.id_from) == str(user.id): tmp = user.format_list() last_message = message.format_last(user.id) last_message['message'] = self.__get_message(last_message) tmp['last_message'] = last_message tmp['favorite'] = False users_list.append(tmp) elif str(message.id_to_user) == str(user.id): message_user = User.where('id', message.id_from).first() if message_user is not None: tmp = message_user.format_list() last_message = message.format_last(message_user.id) last_message['message'] = self.__get_message(last_message) tmp['last_message'] = last_message tmp['favorite'] = False users_list.append(tmp) # users with birthday today birthday_day = datetime.datetime.now().strftime('%d') birthday_month = datetime.datetime.now().strftime('%m') users_with_birthday = User.where_raw( '(EXTRACT(MONTH FROM birthday) = ' + birthday_month + ' AND EXTRACT(DAY FROM birthday) = ' + birthday_day + ')') \ .limit(Config.get('home_screen.birthday_limit')) \ .get() for user_with_b in users_with_birthday: formatted_user = user_with_b.format_list() formatted_user['last_message'] = {} formatted_user['favorite'] = False users_list.append(formatted_user) return users_list
def make_response(self, data, message=None, actions=[], format='json', values_is_string=True): self.__response_format = format if self.__response: raise Exception( "You can execute make_response only once per request.") if format == 'json': if values_is_string: data = CoreHelpers.convert_to_string(data=data) self.__response_hash = CoreHelpers.response_hash if self.__json_data is not None and self.__json_data.get( 'hash') is not None: md5 = hashlib.md5() md5.update(self.__response_hash.encode('utf-8')) server_hash = md5.hexdigest() if server_hash == self.__json_data.get('hash'): self.set_status( Config.get('response_codes.nothing_changed')) data = {} self.__response = { "data": data, "actions": actions, "message": "" if message is None else str(message) } elif format == 'html' or format == 'text': self.__response = str(data) else: raise Exception('Unknown response format.')
def messages(self): user = self.get_user() id_from = self._json_data.get('id_from') limit = int( self._json_data.get('limit', Config.get('user_messages.limit'))) if id_from: user_from = User.where('id', '=', id_from).first() if user_from: from app.models.Message import Message formatted_messages = [] messages = Message.where({'id_from': id_from, 'id_to_user': user.id})\ .or_where({'id_from': user.id, 'id_to_user': id_from})\ .order_by('created_at', 'desc')\ .offset(self.get_offset())\ .limit(limit)\ .get() for message in messages: id_to_user = message.id_to_user formatted_message = message.format_receiver() if str(formatted_message['user_id']) == str(user.id): formatted_message['is_owner'] = True formatted_message['user_id'] = id_to_user else: formatted_message['is_owner'] = False formatted_messages.append(formatted_message) self.make_response({'messages': formatted_messages}) else: self.make_actions(['user_notfound']) else: raise Exception('id_from is required')
def reset_password(self): email = None if self._json_data is not None: email = self._json_data.get('email') if email is not None and email: if re.match(Config.get('email_regexp'), email): user = User.where('email', '=', email).first() if user is None: user_social = UserSocial.where('email', '=', email).first() if user_social is not None: user = user_social.user if user is not None: user.reset_password() app_name = None headers = self.get_request().headers try: app_name = headers['Application-Name'] except: pass from core.helpers.Events import Events Events.password_reset( dict(email=email, reset_pass_token=user.reset_pass_token, app_name=app_name)) self.make_response({}) else: self.make_message("User with this email not found.") else: self.make_message("Incorrect email format.") else: self.make_message('Email is required.')
def validate(data, rules, messages = None): if messages is None: #from app.config.validation import config as validation_messages #messages = validation_messages messages = Config.get('validation_messages', 'validation') result = Result(messages) for attr, attr_rules in rules.items(): attr_rules_list = attr_rules.strip().split('|') if len(attr_rules_list) >= 1: for rule in attr_rules_list: rule_arr = rule.split(':') static_method = 'validate' + '_' + rule if len(rule_arr) == 1: passed = getattr(Rules, static_method)(attr, data.get(attr)) if passed is False: result.add_error(attr, rule, data.get(attr)) elif len(rule_arr) == 2: static_method = 'validate' + '_' + rule_arr[0] passed = getattr(Rules, static_method)(attr, data.get(attr), rule_arr[1]) if passed is False: result.add_error(attr, rule_arr[0], data.get(attr), rule_arr[1]) elif len(rule_arr) == 3: static_method = 'validate' + '_' + rule_arr[0] passed = getattr(Rules, static_method)(attr, data.get(attr), rule_arr[1], rule_arr[2]) if passed is False: result.add_error(attr, rule_arr[0], data.get(attr), rule_arr[1], rule_arr[2]) return result
def save(self): if hasattr(self, 'photo') and self.photo and ( self.photo.find('http://') != -1 or self.photo.find('https://') != -1): import urllib.request try: file_name = str(uuid.uuid4()) + '.jpg' # save image from url to our server urllib.request.urlretrieve( self.photo, Config.get('root_dir') + Config.get('upload_dir') + file_name) # save to database correct path self.photo = Config.get('upload_dir') + file_name except: pass super().save()
def validate_unique(attr, value, table): #import app.config.db as db_config from core.models.Connection import Connection #Connection.init(db_config.connection) Connection.init(Config.get('config', 'db_config')) db = Connection.get_db() result = not db.table(table).where(attr, '=', value).count() > 0 return result
def reset_password(self): self.reset_pass_token = str(uuid.uuid4()) date_timestamp = (Config.get('reset_pass_expires') * 3600) + int( time.time()) date_expire = datetime.datetime.fromtimestamp( date_timestamp).isoformat(' ') self.reset_pass_expires = date_expire self.save()
def client_error_callback(data): raw_html = str(data) html_msg = '<!DOCTYPE html><html><body>' + raw_html + '</body></html>' for email in Config.get('admin_emails'): mailer = Mailer() mailer.to(email) mailer.subject('Client error callback') raw_html mailer.html(html_msg) mailer.send()
def password_reset(dict_obj): mailer = Mailer() mailer.to(dict_obj.get('email')) mailer.subject('Password recovery') restore_url = Config.get('host') + '/user/change_password?reset_token=' + dict_obj.get('reset_pass_token') raw_html = '<p>To restore your password using browser please click <a href="' + restore_url + '">here</a></p>' if dict_obj.get('app_name') is not None: raw_html += '<p>To restore your password using application please click <a href="' + restore_url + '&redirect=' + dict_obj.get('app_name') + '">here</a></p>' html_msg = '<!DOCTYPE html><html><body>' + raw_html + '</body></html>' mailer.html(html_msg) mailer.send()
async def send(self): user_exists = await self.__set_user() if user_exists: reader = await self.get_request().multipart() # /!\ Don't forget to validate your inputs /!\ file = await reader.next() # filename = file.filename unique_filename = str(uuid.uuid4()) # You cannot rely on Content-Length if transfer is chunked. size = 0 file_path = os.path.join(Config.get('upload_dir'), unique_filename) path = Config.get('root_dir') + file_path with open(path, 'wb') as f: while True: chunk = await file.read_chunk() # 8192 bytes by default. if not chunk: break size += len(chunk) f.write(chunk) mime_type = magic.from_file(path, mime=True) file_extension = mimetypes.guess_extension(mime_type, False) if file_extension == '.jpe': file_extension = '.jpeg' os.rename(path, path + file_extension) file_path += file_extension file_model = UploadedFile() file_model.file = file_path file_model.file_name = unique_filename + file_extension file_model.user_id = self.get_user().id file_model.save() # self.make_response(file_model.formatDefault()) self.make_response(file_model.formatDefault())
def __set_lang(self): default_lang = Config.get('default.lang') current_lang = None get_params = self.get() if get_params is not None and 'lang' in get_params: if Lang.exists(get_params['lang']): current_lang = get_params['lang'] if current_lang is None: post_params = self.post() if post_params is not None and 'lang' in post_params: if Lang.exists(post_params['lang']): current_lang = post_params['lang'] if current_lang is None: current_lang = default_lang Lang.set(current_lang)
def find_users(self): user = self.get_user() is_home_screen = self._json_data.get('is_home_screen', False) users_list = [] if is_home_screen: users_list = self.__get_home_screen() else: limit = Config.get('user_contacts.limit') if self._json_data is not None and self._json_data.get( 'limit') is not None: if int(self._json_data.get('limit')) > 0: limit = int(self._json_data.get('limit')) if 'term' in self._json_data and self._json_data['term'].strip(): term = ' | '.join(self._json_data['term'].split()) users = User.where_raw("(textsearchable_index_col @@ to_tsquery('" + term + "') AND users.id <> " + str( user.id) + ") AND (photo is not NULL or first_name is not NULL or last_name is not NULL)") \ .offset(self.get_offset()) \ .limit(limit) \ .get() else: users = User.where_raw( '(photo is not NULL or first_name is not NULL or last_name is not NULL) AND users.id <> ' + str( user.id) + '') \ .offset(self.get_offset()) \ .limit(limit) \ .get() for usr in users: formatted_user = usr.format_list() last_message = usr.get_last_message() if last_message: # for none text messages show <Image> or <Document> kind = last_message.get('kind') if kind and kind != 'text': if kind == 'image': last_message['message'] = '<Image>' if kind == 'doc': last_message['message'] = '<Document>' formatted_user['last_message'] = last_message formatted_user['favorite'] = True if user.favorites.where( 'favorite_id', usr.id).first() is not None else False users_list.append(formatted_user) self.make_response({'users': users_list, 'count': len(users_list)})
def _format_date(self, date): if self.date_format is not None: if self.date_format == 'unix_timestamp': str_date = super()._format_date(date) if type(str_date) is str: dt = datetime.datetime.strptime(str_date, "%Y-%m-%d %H:%M:%S.%f") seconds = int(time.mktime(dt.timetuple())) server_timezone = Config.get('server_timezone') if server_timezone: shift = int(server_timezone) * 3600 seconds += shift return seconds else: return None else: return super()._format_date(date) return super()._format_date(date)
def convert_to_string(data, target=None): if target is None: target = data if settings.CUR_APP_NAME == 'digimundus': return target if type(data) == dict: for key, val in data.items(): if (key == 'file' or key == 'photo') and val: val = Config.get('host') + val if key == 'id': data['ident'] = data[key] del data[key] key = 'ident' if data[key] is None: data[key] = "" CoreHelpers.add_to_response_hash(key, "") elif CoreHelpers.is_convertable(val): data[key] = str(val) CoreHelpers.add_to_response_hash(key, data[key]) elif type(val) is dict: data[key] = CoreHelpers.convert_to_string(val, val) elif type(val) is list: for i, list_val in enumerate(val): if CoreHelpers.is_convertable(list_val): data[key][i] = str(list_val) elif type(list_val) is dict or type(list_val) is list: data[key][i] = CoreHelpers.convert_to_string( list_val, list_val) elif type(data) == list: for i, list_val in enumerate(data): if CoreHelpers.is_convertable(list_val): data[i] = str(list_val) else: data[i] = CoreHelpers.convert_to_string(list_val, list_val) return target
def get_one(self): response = None if self._method == 'POST': if not self._json_data: self.make_message('Required params is absent') return else: action = self._json_data.get('action') if action: config = Config.get('get_one.' + action, 'admin') if config.get('model') and config.get('field'): field = config.get('field') if self._json_data.get(field) is not None: arr = config.get('model').strip().split(':') model_name = arr[0] formatter = arr[1] model = getattr( importlib.import_module( 'app.models.' + model_name, model_name), model_name) model_result = model.where( field, '=', self._json_data.get(field)).first() if model_result is not None: response = getattr(model_result, formatter)() else: response = {} else: raise Exception('Param "' + field + '" is required') else: raise Exception( 'Params "model" and "field" are required') else: self.make_message('Action is not defined') return self.make_response(response)
title="FLIC") # App.router.add_get('/', handle) # App.router.add_get('/{name}', handle) # add middlewares for appliction def setup_middlewares(App): print('errors setup') error_middleware = error_handler(Config.get("errors")) App.middlewares.append(error_middleware) # application entry point setup_middlewares(App) # web.run_app(App, port=8001) loop = asyncio.get_event_loop() async def init_redis(port): from app.helpers.Redis import Redis conn = await aioredis.create_connection(('localhost', port), loop=loop) Redis.set_connection(conn) # conn.close() # await conn.wait_closed() redis_port = Config.get('redis.port') loop.run_until_complete(init_redis(redis_port))
def __init__(self, config_name='mail'): self.__config = Config.get(config_name, 'main')
def send_actions(self, actions): self.set_next(False) self.get_controller().set_status(Config.get('response_codes.error')) self.get_controller().make_response({}, actions=actions)
def __check_device(self, device_os): return device_os in Config.get('user_pushes.device_types')
def update_profile(self): user = self.get_user() new_password = self._json_data.get('new_password') old_password = self._json_data.get('old_password') if new_password and old_password: if not user.is_social: if user.password_correct(old_password): user.set_password(new_password) user.save() self.make_response(user.format_default()) else: self.make_message('Incorrect old password.') else: self.make_message('Please signup to change your password.') else: attrs = ['first_name', 'last_name', 'name', 'email', 'photo'] not_empty_keys = ['email'] for key in attrs: new_value = self._json_data.get(key) if new_value is not None and new_value: if key == 'email': if re.match(Config.get('email_regexp'), new_value): email_exists = User.where('id', '<>', user.id).where( 'email', '=', new_value).exists() if not email_exists: user.email = new_value else: self.make_message("This email already taken.") return else: self.make_message("Invalid email format.") return elif key == 'photo': from app.models.UploadedFile import UploadedFile file_object = UploadedFile.get_by_urls(new_value, is_single=True) if file_object is not None: user.photo = file_object.file file_object.delete() elif key == 'name': names = new_value.strip().split(' ') if len(names) == 1: user.first_name = names[0] elif len(names) == 2: user.first_name = names[0] user.last_name = names[1] elif len(names) > 2: user.first_name = names[0] names.pop(0) user.last_name = ' '.join(names) else: setattr(user, key, new_value) elif key not in not_empty_keys and new_value is not None: if key is 'name': user.first_name = '' user.last_name = '' elif key is 'photo': # remove file physically setattr(user, key, '') else: setattr(user, key, '') user.save() self.make_response(user.format_default())
def make_actions(self, actions): self.set_status(Config.get('response_codes.error')) self.make_response({}, actions=actions)
async def handle(request): try: # request.rel_url is instance of "URL" object # remove hash from url url = str(request.rel_url).replace('#', '') url_params = url.split('?') get_params = None # if we have get params if len(url_params) > 1: # cut get params from main route url = url_params[0] # get string of get params parsed_url = urlparse(url_params[1]) # convert get params from string to dictionary get_params = parse_qsl(parsed_url.path) # print(request.match_info) # set current_route as it was added in request_object current_route = url.split('/') action = current_route.pop() # if we using not /api/v1/controller/action and just controller/action (for frontend) if len(current_route) >= 3: version = current_route[2] else: version = 'v1' handler = request_object.get(url) if handler is not None: current_route = '/'.join(current_route) + '/' + action else: current_route = '/'.join(current_route) + '/{action}' handler = request_object.get(current_route) # if controller.action exists if handler is not None and len(handler) in range(1, 3): controller_class = handler[0] # create controller object instance = controller_class(request) # init get parameters instance.set_get_params(get_params) # check if controller is upload - we need other handler # check for existing controller's action versionized_action_exists = hasattr(instance, action + '_' + version) action_exists = hasattr(instance, action) if action_exists or versionized_action_exists: if versionized_action_exists: is_async = asyncio.iscoroutinefunction( getattr(instance, action + '_' + version)) else: is_async = asyncio.iscoroutinefunction( getattr(instance, action)) if is_async is False: json_data = None post_params = await request.post() try: json_data = await request.json() except Exception: pass # init parameters instance.set_post_params(post_params) instance.set_json_data(json_data) # execute middlewares if len(handler) == 2: if instance.get_request().method != 'OPTIONS': middlewares = handler[1] for middleware in middlewares: middleware_module = importlib.import_module( 'app.middlewares.' + middleware, middleware) middleware_obj = getattr( middleware_module, middleware)(instance) middleware_obj.handle() if middleware_obj.get_next() is False: return send_response( web, middleware_obj.get_controller()) # execute controller action from route if hasattr(instance, '_before'): getattr(instance, '_before')() result = getattr(instance, 'index')(action, version) # return web.HTTPFound('http://absolute.url/and/path/if/you/want') if result is not None: return result else: # middlewares ??? await getattr(instance, 'index_async')(action, version) else: # call handle_404 from middlewares/HandleErrors return web.Response(status=404) else: raise Exception('Can not find route for url ' + url) log_text = "<div><ul><li style='color: blue;'>" + datetime.datetime.now( ).strftime("%Y-%m-%d %H:%M:%S") + "</li>" headers_str = '<ul>' for header in request.headers: headers_str += "<li><strong>{0}</strong>: {1}</li>".format( header, request.headers[header]) log_text += "<li><i>" + str(request.rel_url) + "</i></li>" log_text += "<li>" + headers_str + "</ul></li>" log_text += "<li>" + str(instance.json()) + "</li>" log_text += "<li>" + str(instance.get_response()) + "</li></ul></div>" log_filename = expanduser( "~" ) + "/dev/static_" + settings.CUR_APP_NAME + "/apilog/" + datetime.datetime.now( ).strftime("%Y-%m-%d") + ".html" logfile = open(log_filename, 'a') logfile.write(log_text) logfile.close() return send_response(web, instance) except Exception as exception: from app.helpers.Mailer import Mailer from time import gmtime, strftime import traceback import random import string for email in Config.get('admin_emails'): mailer = Mailer() mailer.to(email) mailer.subject('Exception Error') raw_html = '' for raw in traceback.format_exc().splitlines(): raw_html += raw + '</br >' html = '<html><body>' + raw_html + '</body></html>' s = string.ascii_lowercase + string.digits filename = strftime("%Y-%m-%d_%H:%M:%S_", gmtime()) + ''.join( random.sample(s, 10)) + '.html' file_exception = open( '/home/dev/dev/static_' + settings.CUR_APP_NAME + '/exceptions/' + filename, 'w') file_exception.write(html) file_exception.close() html_msg = '<html><body><a href="http://46.101.254.89/static_' + settings.CUR_APP_NAME + '/exceptions/' \ + filename + '">' + str(exception) + '</a></body></html>' mailer.html(html_msg) mailer.send() return web.Response(status=500)
def send_message(self, message): self.set_next(False) self.get_controller().set_status(Config.get('response_codes.message')) self.get_controller().make_response({}, message=message)
def setup_middlewares(App): print('errors setup') error_middleware = error_handler(Config.get("errors")) App.middlewares.append(error_middleware)
def set_api_token_error_status(self): self.get_controller().set_status( Config.get('response_codes.api_token_error'))
def validate_email(attr, value): import re result = re.match(Config.get('email_regexp'), value) return False if result is None else True
def make_message(self, message, actions=[]): self.set_status(Config.get('response_codes.message')) self.make_response({}, message=message, actions=actions)