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)
