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)
def validate_email(attr, value): import re result = re.match(Config.get('email_regexp'), value) return False if result is None else True
def setup_middlewares(App): print('errors setup') error_middleware = error_handler(Config.get("errors")) App.middlewares.append(error_middleware)
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)
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 set_api_token_error_status(self): self.get_controller().set_status( Config.get('response_codes.api_token_error'))
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 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 make_message(self, message, actions=[]): self.set_status(Config.get('response_codes.message')) self.make_response({}, message=message, actions=actions)
def make_actions(self, actions): self.set_status(Config.get('response_codes.error')) self.make_response({}, actions=actions)
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 login_social(self): # self._json_data # social_alias = self.post('social_alias') # token = self.post('token') token = self._json_data.get('token') social_alias = self._json_data.get('social_alias') is_agree = True if self._json_data and self._json_data.get( 'is_agree') else False # if is_agree is not True: # self.make_message('Please confirm terms agreement.') if social_alias: from core.helpers.Social import Social if token or social_alias == 'twitter': # response = Social.get_facebook_user(token) response = Social.get_user(social_alias, token, self._json_data) # if social_alias == 'twitter': # @TODO: make method in Social helper for getting user avatar if response is not None: social_config = Social.get_config() user_social = None for field in Social.get_social_fields(social_alias): if field[0] == 'social_ident': ident_key = field[1] ident_value = Config.get(ident_key, response) user_social = UserSocial.find_by_ident( ident_value, social_alias) if user_social is None: if is_agree is not True: self.make_message( 'Please confirm terms agreement.', ['goto_auth']) else: user_social = UserSocial() user = User() user_social.alias = social_alias for field in Social.get_social_fields( social_alias): social_key = field[1] if len( field) >= 2 else field[0] # value = response.get(social_key) value = Config.get(social_key, response) # execute all function defined in fields if len(field) > 2: for i, func in enumerate(field): if i > 1: value = func(value) if value is not None: setattr(user_social, field[0], value) user_field_val = social_config[ social_alias]['social_to_user'].get( field[0]) if user_field_val is not None: setattr(user, user_field_val, value) # social media returned not empty user unique identifier if hasattr(user_social, 'social_ident' ) and user_social.social_ident: user.generate_token() from core.models.Connection import Connection with Connection.get_db().transaction(): user.is_social = True user.save() if user.add_role_group('api'): user_social.user_id = user.id user_social.save() self.make_response( user_social.user.format_default()) else: user.delete() raise Exception( 'cant create user role.') else: self.make_message( 'Cant get social media user unique identifier.' ) else: # user already exists. wee need return existing user self.make_response(user_social.user.format_default()) else: self.make_actions(['invalid_oauth2_token']) else: self.make_actions(['parameter_token_required']) else: self.make_actions(['parameter_social_alias_required'])
#import app.config.db as db_config import core.models.Connection as Connection import datetime, time from core.models.Position import Position from core.helpers.Config import Config ConnStaticClass = Connection.Connection postgres = Config.get('postgres', 'db_config') ConnStaticClass.init({'postgres': postgres}) ConectionModel = ConnStaticClass.get_model() class ModelCore(ConectionModel): date_format = 'unix_timestamp' _array_fields = [] # left only specified keys in dictionary def _left_keys(self, keys): data = self.to_dict() new_dict = {} if data: for key in keys: key_to_set = data.get(key) if key_to_set is not None: new_dict[key] = data[key] else: new_dict[key] = "" return new_dict # remove specified keys from dictionary