def register_user(self, data, req_info, curs=None):
env_name = data.get('environment_name')
env_f = EnvironmentFilter({'name': env_name}, {}, None)
env = env_f.filter_one_obj(curs)
# creating user
a = Authenticator()
salt = a.salt()
lang = data.get('lang', User.DEFAULT_LANG)
u_data = {'environment_id': env.id, 'email': data.get('email'),
'password': a.encrypt_password(data.get('password'), salt),
'salt': salt, 'role': User.ROLE_USER,
'lang': lang}
group_f = GroupFilter(env.id, {'is_default': True}, {}, None)
groups = group_f.filter_objs(curs)
groups_ids = [g.id for g in groups]
u_data['groups_ids'] = groups_ids
user = User(**u_data)
# For correct action logging
data['environment_id'] = env.id
try:
mapping.save(curs, user)
except ObjectCreationError:
raise UserAlreadyExists
auth = Authenticator()
session = auth.create_session(curs, env, user, req_info)
_add_log_info(data, session)
n = Notifier()
n_process = n.register_user(curs, user, session)
return response_ok(session_id=session.session_id, id=user.id,
notification=n_process)
def login(self, data, req_info, curs=None):
f = EnvironmentFilter(data, {}, None)
env = f.filter_one_obj(curs)
# Required for proper logging action
data['environment_id'] = env.id
f_params = {'environment_id': env.id, 'email': data.get('email')}
f = SubjectUserFilter(env.id, f_params, {}, None)
try:
user = f.filter_one_obj(curs)
except UserNotFound:
raise UserAuthError
if not user.is_active:
raise UserInactive()
# checking password
auth = Authenticator()
enc_p = auth.encrypt_password(data.get('password'), user.salt)
if enc_p != user.password:
raise UserAuthError
# creating session
bind_to_ip = data.get('bind_to_ip', False)
lt_minutes = data.get('fixed_lifetime_minutes')
session = auth.create_session(curs, env, user, req_info,
bind_to_ip=bind_to_ip, lifetime_minutes=lt_minutes)
_add_log_info(data, session)
return response_ok(session_id=session.session_id,
user_id=session.user_id, environment_id=session.environment_id)
def load_new_notifications(self, data, req_info, session, curs=None):
f = NotificatonFilter(session.environment_id, {}, {}, None)
objs = f.filter_objs(curs, for_update=True)
e_names_cur = [o.event for o in objs]
e_names_to_load = [e_name for e_name in message.EVENTS if e_name not in e_names_cur]
env_f = EnvironmentFilter({'id': session.environment_id}, {}, None)
env = env_f.filter_one_obj(curs)
self._create_default_notifications(curs, env, e_names_to_load)
return response_ok(loaded=len(e_names_to_load))
def restore_password(self, data, req_info, curs=None):
env_name = data.get('environment_name')
env_f = EnvironmentFilter({'name': env_name}, {}, None)
env = env_f.filter_one_obj(curs)
# For correct action logging
data['environment_id'] = env.id
user_f = SubjectUserFilter(env.id, {'email': data.get('email')}, {}, None)
user = user_f.filter_one_obj(curs)
# creating user session
auth = Authenticator()
session = auth.create_restore_password_session(curs, env, user, req_info,
lifetime_minutes=settings.session_restore_password_lifetime_minutes)
_add_log_info(data, session)
n = Notifier()
n_process = n.restore_password(curs, user, session)
return response_ok(notification=n_process)
def get_environment_by_name(self, name, curs=None):
f = EnvironmentFilter({'name': name}, {}, {})
return f.filter_one_obj(curs)
def get_env_name(self, curs, env_id):
f = EnvironmentFilter({'id': env_id}, {}, None)
env = f.filter_one_obj(curs)
return env.name
def get_environment(self, data, req_info, session, curs=None):
f = EnvironmentFilter({'id': session.environment_id}, {}, None)
env = f.filter_one_obj(curs)
return response_ok(environment=env.to_dict())
