def create_user(self, context, request: TracimRequest, hapic_data=None):
"""
Create new user
"""
app_config = request.registry.settings["CFG"] # type: CFG
uapi = UserApi(
current_user=request.current_user,
session=request.dbsession,
config=app_config # User
)
gapi = GroupApi(
current_user=request.current_user,
session=request.dbsession,
config=app_config # User
)
groups = [gapi.get_one_with_name(hapic_data.body.profile)]
password = hapic_data.body.password
if not password and hapic_data.body.email_notification:
password = password_generator()
user = uapi.create_user(
auth_type=AuthType.UNKNOWN,
email=hapic_data.body.email,
password=password,
timezone=hapic_data.body.timezone,
lang=hapic_data.body.lang,
name=hapic_data.body.public_name,
do_notify=hapic_data.body.email_notification,
groups=groups,
do_save=True,
)
uapi.execute_created_user_actions(user)
return uapi.get_user_with_context(user)
def create_user(self, context, request: TracimRequest, hapic_data=None):
"""
Create new user. Note: One of username or email required.
"""
app_config = request.registry.settings["CFG"] # type: CFG
uapi = UserApi(
current_user=request.current_user, session=request.dbsession, config=app_config # User
)
if hapic_data.body.profile:
profile = Profile.get_profile_from_slug(hapic_data.body.profile)
else:
profile = None
password = hapic_data.body.password
if not password and hapic_data.body.email_notification:
password = password_generator()
user = uapi.create_user(
auth_type=AuthType.UNKNOWN,
email=hapic_data.body.email,
password=password,
timezone=hapic_data.body.timezone,
lang=hapic_data.body.lang,
name=hapic_data.body.public_name,
username=hapic_data.body.username,
do_notify=hapic_data.body.email_notification,
allowed_space=hapic_data.body.allowed_space,
profile=profile,
do_save=True,
)
uapi.execute_created_user_actions(user)
return uapi.get_user_with_context(user)
def create_event(
self,
entity_type: EntityType,
operation: OperationType,
additional_fields: Dict[str, JsonDict],
context: TracimContext,
entity_subtype: Optional[str] = None,
) -> Event:
current_user = context.safe_current_user()
user_api = UserApi(
current_user=current_user,
session=context.dbsession,
config=self._config,
show_deleted=True,
)
if current_user:
author = self.user_schema.dump(
user_api.get_user_with_context(current_user)).data
else:
author = None
fields = {
Event.AUTHOR_FIELD: author,
Event.CLIENT_TOKEN_FIELD: context.client_token,
}
fields.update(additional_fields)
event = Event(
entity_type=entity_type,
operation=operation,
entity_subtype=entity_subtype,
fields=fields,
)
context.dbsession.add(event)
context.pending_events.append(event)
return event
def _create_subscription_event(self, operation: OperationType,
subscription: WorkspaceSubscription,
context: TracimContext) -> None:
current_user = context.safe_current_user()
workspace_api = WorkspaceApi(
session=context.dbsession,
config=self._config,
current_user=None,
)
workspace_in_context = workspace_api.get_workspace_with_context(
workspace_api.get_one(subscription.workspace_id))
user_api = UserApi(current_user,
context.dbsession,
self._config,
show_deleted=True)
subscription_author_in_context = user_api.get_user_with_context(
subscription.author)
fields = {
Event.WORKSPACE_FIELD:
EventApi.workspace_schema.dump(workspace_in_context).data,
Event.SUBSCRIPTION_FIELD:
EventApi.workspace_subscription_schema.dump(subscription).data,
Event.USER_FIELD:
EventApi.user_schema.dump(subscription_author_in_context).data,
}
event_api = EventApi(current_user, context.dbsession, self._config)
event_api.create_event(
entity_type=EntityType.WORKSPACE_SUBSCRIPTION,
operation=operation,
additional_fields=fields,
context=context,
)
def create_user(self, context, request: TracimRequest, hapic_data=None):
"""
Create new user
"""
app_config = request.registry.settings['CFG']
uapi = UserApi(
current_user=request.current_user, # User
session=request.dbsession,
config=app_config,
)
gapi = GroupApi(
current_user=request.current_user, # User
session=request.dbsession,
config=app_config,
)
groups = [gapi.get_one_with_name(hapic_data.body.profile)]
password = hapic_data.body.password
if not password and hapic_data.body.email_notification:
password = password_generator()
user = uapi.create_user(
auth_type=AuthType.UNKNOWN,
email=hapic_data.body.email,
password=password,
timezone=hapic_data.body.timezone,
lang=hapic_data.body.lang,
name=hapic_data.body.public_name,
do_notify=hapic_data.body.email_notification,
groups=groups,
do_save=True
)
return uapi.get_user_with_context(user)
def create_user(self, context, request: TracimRequest, hapic_data=None):
"""
Create new user
"""
app_config = request.registry.settings['CFG']
uapi = UserApi(
current_user=request.current_user, # User
session=request.dbsession,
config=app_config,
)
gapi = GroupApi(
current_user=request.current_user, # User
session=request.dbsession,
config=app_config,
)
groups = [gapi.get_one_with_name(hapic_data.body.profile)]
user = uapi.create_user(email=hapic_data.body.email,
password=hapic_data.body.password,
timezone=hapic_data.body.timezone,
lang=hapic_data.body.lang,
name=hapic_data.body.public_name,
do_notify=hapic_data.body.email_notification,
groups=groups,
do_save=True)
return uapi.get_user_with_context(user)
def add_permission_to_workspace(
self,
workspace: Workspace,
emails: typing.List[str],
password: typing.Optional[str] = None,
do_notify=False,
) -> typing.List[UploadPermission]:
upload_permissions = []
created = datetime.utcnow()
upload_permission_group_uuid = str(uuid.uuid4().hex)
for email in emails:
upload_permission = UploadPermission(
author=self._user,
workspace_id=workspace.workspace_id,
email=email.lower(),
token=str(uuid.uuid4()),
password=password,
type=UploadPermissionType.EMAIL,
created=created,
upload_permission_group_uuid=upload_permission_group_uuid,
enabled=True,
)
self.save(upload_permission)
upload_permissions.append(upload_permission)
self._session.flush()
if do_notify:
userlib = UserApi(config=self._config,
current_user=self._user,
session=self._session)
workspace_lib = WorkspaceApi(config=self._config,
current_user=self._user,
session=self._session)
try:
email_manager = self._get_email_manager(
self._config, self._session)
email_manager.notify_upload_permission(
emitter=userlib.get_user_with_context(self._user),
workspace_in_context=workspace_lib.
get_workspace_with_context(workspace),
upload_permission_receivers=self.
get_upload_permissions_in_context(upload_permissions),
upload_permission_password=password,
)
# FIXME - G.M - 2018-11-02 - hack: accept bad recipient user creation
# this should be fixed to find a solution to allow "fake" email but
# also have clear error case for valid mail.
except SMTPRecipientsRefused:
logger.warning(
self,
"Upload Permission initied by user {} but SMTP "
"server refuse to send notification".format(
self._user.login),
)
except SMTPException as exc:
raise NotificationSendingFailed(
"Notification for Upload Permission can't be send "
"(SMTP error).") from exc
return upload_permissions
def user_disk_space(self, context, request: TracimRequest, hapic_data=None):
"""
Get user space infos.
"""
app_config = request.registry.settings["CFG"] # type: CFG
uapi = UserApi(
current_user=request.current_user, session=request.dbsession, config=app_config # User
)
return uapi.get_user_with_context(request.candidate_user)
def user(self, context, request: TracimRequest, hapic_data=None):
"""
Get user infos.
"""
app_config = request.registry.settings['CFG']
uapi = UserApi(
current_user=request.current_user, # User
session=request.dbsession,
config=app_config,
)
return uapi.get_user_with_context(request.candidate_user)
def users(self, context, request: TracimRequest, hapic_data=None):
"""
Get all users
"""
app_config = request.registry.settings["CFG"] # type: CFG
uapi = UserApi(
current_user=request.current_user, session=request.dbsession, config=app_config # User
)
users = uapi.get_all()
context_users = [uapi.get_user_with_context(user) for user in users]
return context_users
def account(self, context, request: TracimRequest, hapic_data=None):
"""
Get user infos.
"""
app_config = request.registry.settings['CFG']
uapi = UserApi(
current_user=request.current_user, # User
session=request.dbsession,
config=app_config,
)
return uapi.get_user_with_context(request.current_user)
def whoami(self, context, request: TracimRequest, hapic_data=None):
"""
Return current logged-in user.
If user is not authenticated or the session has expired, a 401 is returned.
This is the recommanded way to check if the user is already authenticated
"""
app_config = request.registry.settings["CFG"] # type: CFG
uapi = UserApi(request.current_user,
session=request.dbsession,
config=app_config)
user = uapi.get_current_user() # User
return uapi.get_user_with_context(user)
def whoami(self, context, request: TracimRequest, hapic_data=None):
"""
Return current logged-in user.
If user is not authenticated or the session has expired, a 401 is returned.
This is the recommanded way to check if the user is already authenticated
"""
app_config = request.registry.settings['CFG']
uapi = UserApi(
request.current_user,
session=request.dbsession,
config=app_config,
)
user = uapi.get_current_user() # User
return uapi.get_user_with_context(user)
def test_unit__get_user_with_context__nominal_case(self):
user = User(email="*****@*****.**", display_name="Admin", is_active=True)
api = UserApi(current_user=None, session=self.session, config=self.app_config)
new_user = api.get_user_with_context(user)
assert isinstance(new_user, UserInContext)
assert new_user.user == user
assert new_user.profile == "nobody"
assert new_user.user_id == user.user_id
assert new_user.email == "*****@*****.**"
assert new_user.display_name == "Admin"
assert new_user.is_active is True
# TODO - G.M - 03-05-2018 - [avatar][agenda] Should test this
# with true value when those param will be available.
assert new_user.avatar_url is None
def set_user_username(self, context, request: TracimRequest, hapic_data=None):
"""
Set user username
"""
app_config = request.registry.settings["CFG"] # type: CFG
uapi = UserApi(
current_user=request.current_user, session=request.dbsession, config=app_config # User
)
user = uapi.set_username(
request.candidate_user,
hapic_data.body.loggedin_user_password,
hapic_data.body.username,
do_save=True,
)
return uapi.get_user_with_context(user)
def set_user_email(self, context, request: TracimRequest, hapic_data=None):
"""
Set user Email
"""
app_config = request.registry.settings['CFG']
uapi = UserApi(
current_user=request.current_user, # User
session=request.dbsession,
config=app_config,
)
user = uapi.set_email(request.candidate_user,
hapic_data.body.loggedin_user_password,
hapic_data.body.email,
do_save=True)
return uapi.get_user_with_context(user)
def users(self, context, request: TracimRequest, hapic_data=None):
"""
Get all users
"""
app_config = request.registry.settings['CFG']
uapi = UserApi(
current_user=request.current_user, # User
session=request.dbsession,
config=app_config,
)
users = uapi.get_all()
context_users = [
uapi.get_user_with_context(user) for user in users
]
return context_users
def set_user_infos(self, context, request: TracimRequest, hapic_data=None):
"""
Set user info data
"""
app_config = request.registry.settings['CFG']
uapi = UserApi(
current_user=request.current_user, # User
session=request.dbsession,
config=app_config,
)
user = uapi.update(request.candidate_user,
name=hapic_data.body.public_name,
timezone=hapic_data.body.timezone,
lang=hapic_data.body.lang,
do_save=True)
return uapi.get_user_with_context(user)
def _create_role_event(self, operation: OperationType,
role: UserRoleInWorkspace,
context: TracimContext) -> None:
current_user = context.safe_current_user()
workspace_api = WorkspaceApi(
session=context.dbsession,
config=self._config,
show_deleted=True,
# INFO - G.M - 2020-17-09 - we do explicitly don't set user here to not
# have filter on workspace, in some case we do want user create event on workspace
# he doesn't have access: when he remove itself from workspace for example
current_user=None,
)
workspace_in_context = workspace_api.get_workspace_with_context(
workspace_api.get_one(role.workspace_id))
user_api = UserApi(current_user,
context.dbsession,
self._config,
show_deleted=True)
role_api = RoleApi(current_user=current_user,
session=context.dbsession,
config=self._config)
try:
user_field = EventApi.user_schema.dump(
user_api.get_user_with_context(user_api.get_one(
role.user_id))).data
except UserDoesNotExist:
# It is possible to have an already deleted user when deleting his roles.
user_field = None
role_in_context = role_api.get_user_role_workspace_with_context(role)
fields = {
Event.USER_FIELD:
user_field,
Event.WORKSPACE_FIELD:
EventApi.workspace_schema.dump(workspace_in_context).data,
Event.MEMBER_FIELD:
EventApi.workspace_user_role_schema.dump(role_in_context).data,
}
event_api = EventApi(current_user, context.dbsession, self._config)
event_api.create_event(
entity_type=EntityType.WORKSPACE_MEMBER,
operation=operation,
additional_fields=fields,
context=context,
)
def set_account_email(self, context, request: TracimRequest, hapic_data=None):
"""
Set user Email
"""
app_config = request.registry.settings['CFG']
uapi = UserApi(
current_user=request.current_user, # User
session=request.dbsession,
config=app_config,
)
user = uapi.set_email(
request.current_user,
hapic_data.body.loggedin_user_password,
hapic_data.body.email,
do_save=True
)
return uapi.get_user_with_context(user)
def login(self, context, request: TracimRequest, hapic_data=None):
"""
Logs the user into the system.
In case of success, the JSON returned is the user profile.
In that case, a cookie is created with a session_key and an expiration date.
Eg. : `session_key=932d2ad68f3a094c2d4da563ccb921e6479729f5b5f707eba91d4194979df20831be48a0; expires=Mon, 22-Oct-2018 19:37:02 GMT; Path=/; SameSite=Lax`
"""
login = hapic_data.body
app_config = request.registry.settings["CFG"] # type: CFG
uapi = UserApi(None, session=request.dbsession, config=app_config)
ldap_connector = None
if AuthType.LDAP in app_config.AUTH_TYPES:
ldap_connector = get_ldap_connector(request)
user = uapi.authenticate(login.email, login.password, ldap_connector)
remember(request, user.user_id)
return uapi.get_user_with_context(user)
def known_members(self, context, request: TracimRequest, hapic_data=None):
"""
Get known users list
"""
app_config = request.registry.settings['CFG']
uapi = UserApi(
current_user=request.candidate_user, # User
session=request.dbsession,
config=app_config,
show_deactivated=False,
)
users = uapi.get_known_user(
acp=hapic_data.query.acp,
exclude_user_ids=hapic_data.query.exclude_user_ids,
exclude_workspace_ids=hapic_data.query.exclude_workspace_ids,
)
context_users = [uapi.get_user_with_context(user) for user in users]
return context_users
def set_account_infos(self, context, request: TracimRequest, hapic_data=None):
"""
Set user info data
"""
app_config = request.registry.settings['CFG']
uapi = UserApi(
current_user=request.current_user, # User
session=request.dbsession,
config=app_config,
)
user = uapi.update(
request.current_user,
name=hapic_data.body.public_name,
timezone=hapic_data.body.timezone,
lang=hapic_data.body.lang,
do_save=True
)
return uapi.get_user_with_context(user)
def set_user_infos(self, context, request: TracimRequest, hapic_data=None):
"""
Set user info data
"""
app_config = request.registry.settings["CFG"] # type: CFG
uapi = UserApi(
current_user=request.current_user, session=request.dbsession, config=app_config # User
)
user = uapi.update(
request.candidate_user,
auth_type=request.candidate_user.auth_type,
name=hapic_data.body.public_name,
timezone=hapic_data.body.timezone,
lang=hapic_data.body.lang,
do_save=True,
)
uapi.execute_updated_user_actions(user)
return uapi.get_user_with_context(user)
def account_known_members(self, context, request: TracimRequest, hapic_data=None):
"""
Get known users list
"""
app_config = request.registry.settings['CFG']
uapi = UserApi(
current_user=request.current_user, # User
session=request.dbsession,
config=app_config,
show_deactivated=False,
)
users = uapi.get_known_user(
acp=hapic_data.query.acp,
exclude_user_ids=hapic_data.query.exclude_user_ids,
exclude_workspace_ids=hapic_data.query.exclude_workspace_ids,
)
context_users = [
uapi.get_user_with_context(user) for user in users
]
return context_users
def _create_user_event(self, operation: OperationType, user: User,
context: TracimContext) -> None:
current_user = context.safe_current_user()
user_api = UserApi(
current_user=current_user,
session=context.dbsession,
config=self._config,
show_deleted=True,
)
fields = {
Event.USER_FIELD:
EventApi.user_schema.dump(
user_api.get_user_with_context(user)).data
}
event_api = EventApi(current_user, context.dbsession, self._config)
event_api.create_event(
entity_type=EntityType.USER,
operation=operation,
additional_fields=fields,
context=context,
)
def known_members(self, context, request: TracimRequest, hapic_data=None):
"""
Get known users list
"""
app_config = request.registry.settings["CFG"] # type: CFG
uapi = UserApi(
current_user=request.candidate_user, # User
session=request.dbsession,
config=app_config,
show_deactivated=False,
)
users = uapi.get_known_users(
acp=hapic_data.query.acp,
exclude_user_ids=hapic_data.query.exclude_user_ids,
exclude_workspace_ids=hapic_data.query.exclude_workspace_ids,
include_workspace_ids=hapic_data.query.include_workspace_ids,
limit=hapic_data.query.limit,
filter_results=app_config.KNOWN_MEMBERS__FILTER,
)
context_users = [uapi.get_user_with_context(user) for user in users]
return context_users
def login(self, context, request: TracimRequest, hapic_data=None):
"""
Logs the user into the system.
In case of success, the JSON returned is the user profile.
In that case, a cookie is created with a session_key and an expiration date.
Eg. : `session_key=932d2ad68f3a094c2d4da563ccb921e6479729f5b5f707eba91d4194979df20831be48a0; expires=Mon, 22-Oct-2018 19:37:02 GMT; Path=/; SameSite=Lax`
"""
login = hapic_data.body
app_config = request.registry.settings['CFG'] # type: CFG
uapi = UserApi(
None,
session=request.dbsession,
config=app_config,
)
ldap_connector = None
if AuthType.LDAP in app_config.AUTH_TYPES:
ldap_connector = get_ldap_connector(request)
user = uapi.authenticate(login.email, login.password, ldap_connector)
remember(request, user.user_id)
return uapi.get_user_with_context(user)
def test_unit__get_user_with_context__nominal_case(self):
user = User(
email='*****@*****.**',
display_name='Admin',
is_active=True,
)
api = UserApi(
current_user=None,
session=self.session,
config=self.app_config,
)
new_user = api.get_user_with_context(user)
assert isinstance(new_user, UserInContext)
assert new_user.user == user
assert new_user.profile == 'nobody'
assert new_user.user_id == user.user_id
assert new_user.email == '*****@*****.**'
assert new_user.display_name == 'Admin'
assert new_user.is_active is True
# TODO - G.M - 03-05-2018 - [avatar][calendar] Should test this
# with true value when those param will be available.
assert new_user.avatar_url is None
assert new_user.calendar_url is None
