def create_template(self, request, **kwargs):
template_name = request.DATA.get('template_name', None)
template_description = request.DATA.get('template_description', None)
if not template_name:
raise ParseError("Not valid template name")
if not template_description:
raise ParseError("Not valid template description")
template_slug = slugify_uniquely(template_name, models.ProjectTemplate)
project = self.get_object()
self.check_permissions(request, 'create_template', project)
template = models.ProjectTemplate(
name=template_name,
slug=template_slug,
description=template_description,
)
template.load_data_from_project(project)
template.save()
return Response(serializers.ProjectTemplateSerializer(template).data,
status=201)
def save(self, *args, **kwargs):
if not self._importing or not self.modified_date:
self.modified_date = timezone.now()
if not self.slug:
base_name = "{}-{}".format(self.owner.username, self.name)
base_slug = slugify_uniquely(base_name, self.__class__)
slug = base_slug
for i in arithmetic_progression():
if not type(self).objects.filter(
slug=slug).exists() or i > 100:
break
slug = "{}-{}".format(base_slug, i)
self.slug = slug
if not self.is_backlog_activated:
self.total_milestones = None
self.total_story_points = None
if not self.videoconferences:
self.videoconferences_extra_data = None
if not self.is_looking_for_people:
self.looking_for_people_note = ""
if self.anon_permissions == None:
self.anon_permissions = []
if self.public_permissions == None:
self.public_permissions = []
super().save(*args, **kwargs)
def create_template(self, request, **kwargs):
template_name = request.DATA.get('template_name', None)
template_description = request.DATA.get('template_description', None)
if not template_name:
raise response.BadRequest(_("Invalid template name"))
if not template_description:
raise response.BadRequest(_("Invalid template description"))
with advisory_lock("create-project-template"):
template_slug = slugify_uniquely(template_name,
models.ProjectTemplate)
project = self.get_object()
self.check_permissions(request, 'create_template', project)
template = models.ProjectTemplate(
name=template_name,
slug=template_slug,
description=template_description,
)
template.load_data_from_project(project)
template.save()
return response.Created(
serializers.ProjectTemplateSerializer(template).data)
def create_from_project(self, request, **kwargs):
project_id = request.DATA.get('project_id', None)
template_name = request.DATA.get('template_name', None)
template_description = request.DATA.get('template_description', None)
if not template_name:
raise ParseError("Not valid template name")
template_slug = slugify_uniquely(template_name, models.ProjectTemplate)
domain = get_active_domain()
try:
project = models.Project.objects.get(domain=domain, pk=project_id)
except models.Project.DoesNotExist:
raise ParseError("Not valid project_id")
template = models.ProjectTemplate(
name=template_name,
slug=template_slug,
description=template_description,
domain=domain,
)
template.load_data_from_project(project)
template.save()
return Response(self.serializer_class(template).data, status=201)
def save(self, *args, **kwargs):
if not self._importing or not self.modified_date:
self.modified_date = timezone.now()
if not self.slug:
base_name = "{}-{}".format(self.owner.username, self.name)
base_slug = slugify_uniquely(base_name, self.__class__)
slug = base_slug
for i in arithmetic_progression():
if not type(self).objects.filter(slug=slug).exists() or i > 100:
break
slug = "{}-{}".format(base_slug, i)
self.slug = slug
if not self.is_backlog_activated:
self.total_milestones = None
self.total_story_points = None
if not self.videoconferences:
self.videoconferences_extra_data = None
if not self.is_looking_for_people:
self.looking_for_people_note = ""
if self.anon_permissions == None:
self.anon_permissions = []
if self.public_permissions == None:
self.public_permissions = []
super().save(*args, **kwargs)
def save(self, *args, **kwargs):
if not self._importing or not self.modified_date:
self.modified_date = timezone.now()
if not self.slug:
self.slug = slugify_uniquely(self.name, self.__class__)
super().save(*args, **kwargs)
def save(self, *args, **kwargs):
if not self._importing or not self.modified_date:
self.modified_date = timezone.now()
if not self.slug:
base_name = "{}-{}".format(self.owner.username, self.name)
base_slug = slugify_uniquely(base_name, self.__class__)
slug = base_slug
for i in arithmetic_progression():
if not type(self).objects.filter(slug=slug).exists() or i > 100:
break
slug = "{}-{}".format(base_slug, i)
self.slug = slug
if not self.videoconferences:
self.videoconferences_salt = None
# binh comments
#if self.pk is None:
# self.is_backlog_activated = True
# self.is_kanban_activated = True
# self.is_wiki_activated = True
super().save(*args, **kwargs)
def create_template(self, request, **kwargs):
template_name = request.DATA.get('template_name', None)
template_description = request.DATA.get('template_description', None)
if not template_name:
raise response.BadRequest(_("Not valid template name"))
if not template_description:
raise response.BadRequest(_("Not valid template description"))
template_slug = slugify_uniquely(template_name, models.ProjectTemplate)
project = self.get_object()
self.check_permissions(request, 'create_template', project)
template = models.ProjectTemplate(
name=template_name,
slug=template_slug,
description=template_description,
)
template.load_data_from_project(project)
template.save()
return response.Created(serializers.ProjectTemplateSerializer(template).data)
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify_uniquely(self.name, self.__class__)
if not self.videoconferences:
self.videoconferences_salt = None
super().save(*args, **kwargs)
def handle(self, *args, **options):
current_slug = options["current_slug"]
new_slug = options["new_slug"]
try:
project = Project.objects.get(slug=current_slug)
except Project.DoesNotExist:
raise CommandError("There is no project with the slug '{}'".format(current_slug))
slug = slugify_uniquely(new_slug, Project)
if slug != new_slug:
raise CommandError("Invalid new slug, maybe you can try with '{}'".format(slug))
# Change slug
self.stdout.write(self.style.SUCCESS("-> Change slug to '{}'.".format(slug)))
project.slug = slug
project.save()
# Reset diff cache in history entries
self.stdout.write(self.style.SUCCESS("-> Reset value_diff cache for history entries."))
HistoryEntry.objects.filter(project=project).update(values_diff_cache=None)
# Regenerate timeline
self.stdout.write(self.style.SUCCESS("-> Regenerate timeline entries."))
rebuild_timeline(None, None, project.id)
def save(self, *args, **kwargs):
if not self._importing or not self.modified_date:
self.modified_date = timezone.now()
if not self.is_backlog_activated:
self.total_milestones = None
self.total_story_points = None
if not self.videoconferences:
self.videoconferences_extra_data = None
if not self.is_looking_for_people:
self.looking_for_people_note = ""
if self.anon_permissions is None:
self.anon_permissions = []
if self.public_permissions is None:
self.public_permissions = []
if not self.slug:
with advisory_lock("project-creation"):
base_slug = "{}-{}".format(self.owner.username, self.name)
self.slug = slugify_uniquely(base_slug, self.__class__)
super().save(*args, **kwargs)
else:
super().save(*args, **kwargs)
def cancel(self):
with advisory_lock("delete-user"):
self.username = slugify_uniquely("deleted-user",
User,
slugfield="username")
self.email = "{}@taiga.io".format(self.username)
self.is_active = False
self.full_name = "Deleted user"
self.color = ""
self.bio = ""
self.lang = ""
self.theme = ""
self.timezone = ""
self.colorize_tags = True
self.token = None
self.set_unusable_password()
self.photo = None
self.save()
self.auth_data.all().delete()
# Blocking all owned projects
self.owned_projects.update(blocked_code=BLOCKED_BY_OWNER_LEAVING)
# Remove all memberships
self.memberships.all().delete()
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify_uniquely(self.name, self.__class__)
if not self.videoconferences:
self.videoconferences_salt = None
super().save(*args, **kwargs)
def register_or_update(username: str, email: str, full_name: str):
"""
Register new or update existing user in Django DB from LDAP data.
Can raise `exc.IntegrityError` exceptions in case of conflict found.
:returns: User
"""
user_model = apps.get_model('users', 'User')
if SLUGIFY:
username = SLUGIFY(username)
try:
# has user logged in before?
user = user_model.objects.get(username=username)
except user_model.DoesNotExist:
# create a new user
username_unique = slugify_uniquely(username,
user_model,
slugfield='username')
user = user_model.objects.create(username=username_unique,
email=email,
full_name=full_name)
user_registered_signal.send(sender=user.__class__, user=user)
else:
# update DB entry if LDAP field values differ
if user.email != email or user.full_name != full_name:
user_object = user_model.objects.filter(pk=user.pk)
user_object.update(email=email, full_name=full_name)
user.refresh_from_db()
return user
def github_register(username: str,
email: str,
full_name: str,
github_id: int,
bio: str,
token: str = None):
"""
Register a new user from github.
This can raise `exc.IntegrityError` exceptions in
case of conflics found.
:returns: User
"""
auth_data_model = apps.get_model("users", "AuthData")
user_model = apps.get_model("users", "User")
try:
# Github user association exist?
auth_data = auth_data_model.objects.get(key="github", value=github_id)
user = auth_data.user
except auth_data_model.DoesNotExist:
try:
# Is a user with the same email as the github user?
user = user_model.objects.get(email=email)
auth_data_model.objects.create(user=user,
key="github",
value=github_id,
extra={})
except user_model.DoesNotExist:
if settings.PUBLIC_REGISTER_ENABLED:
# Create a new user
username_unique = slugify_uniquely(username,
user_model,
slugfield="username")
user = user_model.objects.create(email=email,
username=username_unique,
full_name=full_name,
bio=bio)
auth_data_model.objects.create(user=user,
key="github",
value=github_id,
extra={})
send_register_email(user)
user_registered_signal.send(sender=user.__class__, user=user)
else:
return None
if token:
membership = get_membership_by_token(token)
try:
membership.user = user
membership.save(update_fields=["user"])
except IntegrityError:
raise exc.IntegrityError(
_("This user is already a member of the project."))
return user
def ldap_register(username: str, email: str, full_name: str):
"""
Register a new user from LDAP.
This can raise `exc.IntegrityError` exceptions in
case of conflict found.
:returns: User
"""
user_model = apps.get_model("users", "User")
try:
# LDAP user association exist?
user = user_model.objects.get(username=username)
except user_model.DoesNotExist:
# Create a new user
username_unique = slugify_uniquely(username,
user_model,
slugfield="username")
user = user_model.objects.create(email=email,
username=username_unique,
full_name=full_name)
user_registered_signal.send(sender=user.__class__, user=user)
return user
def gitlab_register(username:str, email:str, full_name:str, gitlab_id:int, bio:str):
"""
Register a new user from gitlab.
This can raise `exc.IntegrityError` exceptions in
case of conflics found.
:returns: User
"""
auth_data_model = apps.get_model("users", "AuthData")
user_model = apps.get_model("users", "User")
try:
# Gitlab user association exist?
auth_data = auth_data_model.objects.get(key="gitlab", value=gitlab_id)
user = auth_data.user
except auth_data_model.DoesNotExist:
try:
# Is a user with the same email as the gitlab user?
user = user_model.objects.get(email=email)
auth_data_model.objects.create(user=user, key="gitlab", value=gitlab_id, extra={})
except user_model.DoesNotExist:
# Create a new user
username_unique = slugify_uniquely(username, user_model, slugfield="username")
user = user_model.objects.create(email=email,
username=username_unique,
full_name=full_name,
bio=bio)
auth_data_model.objects.create(user=user, key="gitlab", value=gitlab_id, extra={})
send_register_email(user)
user_registered_signal.send(sender=user.__class__, user=user)
return user
def save(self, *args, **kwargs):
if not self._importing or not self.modified_date:
self.modified_date = timezone.now()
if not self.slug:
with advisory_lock("milestone-creation-{}".format(self.project_id)):
self.slug = slugify_uniquely(self.name, self.__class__)
super().save(*args, **kwargs)
else:
super().save(*args, **kwargs)
def ping_federate_register(
username: str,
email: str,
full_name: str,
ping_federate_guid: int,
token: str = None,
):
"""
Register a new user from ping federate.
This can raise `exc.IntegrityError` exceptions in
case of conflics found.
:returns: User
"""
auth_data_model = apps.get_model("users", "AuthData")
user_model = apps.get_model("users", "User")
try:
# Ping federate user association exist?
auth_data = auth_data_model.objects.get(
key=USER_KEY,
value=ping_federate_guid,
)
user = auth_data.user
except auth_data_model.DoesNotExist:
try:
# Is a user with the same email as the google user?
user = user_model.objects.get(email=email)
auth_data_model.objects.create(user=user,
key=USER_KEY,
value=ping_federate_guid,
extra={})
except user_model.DoesNotExist:
# Create a new user
username_unique = slugify_uniquely(username,
user_model,
slugfield="username")
user = user_model.objects.create(
email=email,
username=username_unique,
full_name=full_name,
)
auth_data_model.objects.create(user=user,
key=USER_KEY,
value=ping_federate_guid,
extra={})
send_register_email(user)
user_registered_signal.send(sender=user.__class__, user=user)
if token:
membership = get_membership_by_token(token)
membership.user = user
membership.save(update_fields=["user"])
return user
def save(self, *args, **kwargs):
if not self._importing or not self.modified_date:
self.modified_date = timezone.now()
if not self.slug:
with advisory_lock("milestone-creation-{}".format(self.project_id)):
self.slug = slugify_uniquely(self.name, self.__class__)
super().save(*args, **kwargs)
else:
super().save(*args, **kwargs)
def cancel(self):
self.username = slugify_uniquely("deleted-user", User, slugfield="username")
self.email = "{}@taiga.io".format(self.username)
self.is_active = False
self.full_name = "Deleted user"
self.color = ""
self.bio = ""
self.default_language = ""
self.default_timezone = ""
self.colorize_tags = True
self.token = None
self.github_id = None
self.set_unusable_password()
self.save()
def cancel(self):
self.username = slugify_uniquely("deleted-user", User, slugfield="username")
self.email = "{}@taiga.io".format(self.username)
self.is_active = False
self.full_name = "Deleted user"
self.color = ""
self.bio = ""
self.default_language = ""
self.default_timezone = ""
self.colorize_tags = True
self.token = None
self.github_id = None
self.set_unusable_password()
self.save()
def cancel(self):
self.username = slugify_uniquely("deleted-user", User, slugfield="username")
self.email = "{}@taiga.io".format(self.username)
self.is_active = False
self.full_name = "Deleted user"
self.color = ""
self.bio = ""
self.lang = ""
self.theme = ""
self.timezone = ""
self.colorize_tags = True
self.token = None
self.set_unusable_password()
self.delete_photo()
self.save()
self.auth_data.all().delete()
def cancel(self):
self.username = slugify_uniquely("deleted-user", User, slugfield="username")
self.email = "{}@taiga.io".format(self.username)
self.is_active = False
self.full_name = "Deleted user"
self.color = ""
self.bio = ""
self.lang = ""
self.theme = ""
self.timezone = ""
self.colorize_tags = True
self.token = None
self.set_unusable_password()
self.delete_photo()
self.save()
self.auth_data.all().delete()
def destroy(self, request, pk=None):
user = self.get_object()
self.check_permissions(request, "destroy", user)
user.username = slugify_uniquely("deleted-user", models.User, slugfield="username")
user.email = "{}@taiga.io".format(user.username)
user.is_active = False
user.full_name = "Deleted user"
user.color = ""
user.bio = ""
user.default_language = ""
user.default_timezone = ""
user.colorize_tags = True
user.token = None
user.github_id = None
user.set_unusable_password()
user.save()
return Response(status=status.HTTP_204_NO_CONTENT)
def save(self, *args, **kwargs):
if not self._importing or not self.modified_date:
self.modified_date = timezone.now()
if not self.slug:
base_slug = slugify_uniquely(self.name, self.__class__)
slug = base_slug
for i in arithmetic_progression():
if not type(self).objects.filter(slug=slug).exists() or i > 100:
break
slug = "{}-{}".format(base_slug, i)
self.slug = slug
if not self.videoconferences:
self.videoconferences_salt = None
super().save(*args, **kwargs)
def github_register(username: str,
email: str,
full_name: str,
github_id: int,
bio: str,
token: str = None):
"""
Register a new user from github.
This can raise `exc.IntegrityError` exceptions in
case of conflics found.
:returns: User
"""
user_model = apps.get_model("users", "User")
try:
# Github user association exist?
user = user_model.objects.get(github_id=github_id)
except user_model.DoesNotExist:
try:
# Is a user with the same email as the github user?
user = user_model.objects.get(email=email)
user.github_id = github_id
user.save(update_fields=["github_id"])
except user_model.DoesNotExist:
# Create a new user
username_unique = slugify_uniquely(username,
user_model,
slugfield="username")
user = user_model.objects.create(email=email,
username=username_unique,
github_id=github_id,
full_name=full_name,
bio=bio)
send_register_email(user)
user_registered_signal.send(sender=user.__class__, user=user)
if token:
membership = get_membership_by_token(token)
membership.user = user
membership.save(update_fields=["user"])
return user
def save(self, *args, **kwargs):
if not self._importing or not self.modified_date:
self.modified_date = timezone.now()
if not self.slug:
base_name = "{}-{}".format(self.owner.username, self.name)
base_slug = slugify_uniquely(base_name, self.__class__)
slug = base_slug
for i in arithmetic_progression():
if not type(self).objects.filter(slug=slug).exists() or i > 100:
break
slug = "{}-{}".format(base_slug, i)
self.slug = slug
if not self.videoconferences:
self.videoconferences_extra_data = None
super().save(*args, **kwargs)
def destroy(self, request, pk=None):
user = self.get_object()
self.check_permissions(request, "destroy", user)
user.username = slugify_uniquely("deleted-user",
models.User,
slugfield="username")
user.email = "{}@taiga.io".format(user.username)
user.is_active = False
user.full_name = "Deleted user"
user.color = ""
user.bio = ""
user.default_language = ""
user.default_timezone = ""
user.colorize_tags = True
user.token = None
user.github_id = None
user.set_unusable_password()
user.save()
return Response(status=status.HTTP_204_NO_CONTENT)
def cancel(self):
self.username = slugify_uniquely("deleted-user", User, slugfield="username")
self.email = "{}@taiga.io".format(self.username)
self.is_active = False
self.full_name = "Deleted user"
self.color = ""
self.bio = ""
self.lang = ""
self.theme = ""
self.timezone = ""
self.colorize_tags = True
self.token = None
self.set_unusable_password()
self.photo = None
self.save()
self.auth_data.all().delete()
#Blocking all owned users
self.owned_projects.update(blocked_code=BLOCKED_BY_OWNER_LEAVING)
def slack_register(username:str, email:str, full_name:str, slack_id:int, bio:str, token:str=None):
"""
Register a new user from slack.
This can raise `exc.IntegrityError` exceptions in
case of conflics found.
:returns: User
"""
auth_data_model = apps.get_model("users", "AuthData")
user_model = apps.get_model("users", "User")
try:
# slack user association exist?
auth_data = auth_data_model.objects.get(key="slack", value=slack_id)
user = auth_data.user
except auth_data_model.DoesNotExist:
try:
# Is a user with the same email as the slack user?
user = user_model.objects.get(email=email)
auth_data_model.objects.create(user=user, key="slack", value=slack_id, extra={})
except user_model.DoesNotExist:
# Create a new user
username_unique = slugify_uniquely(username, user_model, slugfield="username")
user = user_model.objects.create(email=email,
username=username_unique,
full_name=full_name,
bio=bio)
auth_data_model.objects.create(user=user, key="slack", value=slack_id, extra={})
send_register_email(user)
user_registered_signal.send(sender=user.__class__, user=user)
if token:
membership = get_membership_by_token(token)
try:
membership.user = user
membership.save(update_fields=["user"])
except IntegrityError:
raise exc.IntegrityError(_("This user is already a member of the project."))
return user
def save(self, *args, **kwargs):
if not self._importing or not self.modified_date:
self.modified_date = timezone.now()
if not self.slug:
base_name = "{}-{}".format(self.owner.username, self.name)
base_slug = slugify_uniquely(base_name, self.__class__)
slug = base_slug
for i in arithmetic_progression():
if not type(self).objects.filter(slug=slug).exists() or i > 100:
break
slug = "{}-{}".format(base_slug, i)
self.slug = slug
if not self.videoconferences:
self.videoconferences_extra_data = None
if not self.is_looking_for_people:
self.looking_for_people_note = ""
super().save(*args, **kwargs)
def saml_register(saml_id, user_attributes, token=None):
auth_data_model = apps.get_model('users', 'AuthData')
user_model = apps.get_model('users', 'User')
try:
# SAML user association exist?
auth_data = auth_data_model.objects.get(key="saml", value=saml_id)
user = auth_data.user
except auth_data_model.DoesNotExist:
try:
# Is a there a user with the same email as the SAML user?
user = user_model.objects.get(email=user_attributes['email'])
auth_data_model.objects.create(user=user,
key='saml',
value=saml_id,
extra={})
except user_model.DoesNotExist:
# Create a new user
user_attributes['username'] = slugify_uniquely(
user_attributes['username'], user_model, slugfield='username')
user = user_model.objects.create(**user_attributes)
auth_data_model.objects.create(user=user,
key='saml',
value=saml_id,
extra={})
send_register_email(user)
user_registered_signal.send(sender=user.__class__, user=user)
if token:
membership = get_membership_by_token(token)
try:
membership.user = user
membership.save(update_fields=['user'])
except IntegrityError:
raise exc.IntegrityError(
_("This user is already a member of the project."))
return user
def github_register(username:str, email:str, full_name:str, github_id:int, bio:str, token:str=None):
"""
Register a new user from github.
This can raise `exc.IntegrityError` exceptions in
case of conflics found.
:returns: User
"""
user_model = apps.get_model("users", "User")
try:
# Github user association exist?
user = user_model.objects.get(github_id=github_id)
except user_model.DoesNotExist:
try:
# Is a user with the same email as the github user?
user = user_model.objects.get(email=email)
user.github_id = github_id
user.save(update_fields=["github_id"])
except user_model.DoesNotExist:
# Create a new user
username_unique = slugify_uniquely(username, user_model, slugfield="username")
user = user_model.objects.create(email=email,
username=username_unique,
github_id=github_id,
full_name=full_name,
bio=bio)
send_register_email(user)
user_registered_signal.send(sender=user.__class__, user=user)
if token:
membership = get_membership_by_token(token)
membership.user = user
membership.save(update_fields=["user"])
return user
def ldap_register(username: str, email: str, full_name: str):
"""
Register a new user from LDAP.
This can raise `exc.IntegrityError` exceptions in
case of conflict found.
:returns: User
"""
user_model = apps.get_model("users", "User")
try:
# LDAP user association exist?
user = user_model.objects.get(username=username)
except user_model.DoesNotExist:
# Create a new user
username_unique = slugify_uniquely(username, user_model, slugfield="username")
user = user_model.objects.create(email=email,
username=username_unique,
full_name=full_name)
user_registered_signal.send(sender=user.__class__, user=user)
return user
def create_from_project(self, request, **kwargs):
project_id = request.DATA.get('project_id', None)
template_name = request.DATA.get('template_name', None)
template_description = request.DATA.get('template_description', None)
if not template_name:
raise ParseError("Not valid template name")
template_slug = slugify_uniquely(template_name, models.ProjectTemplate)
try:
project = models.Project.objects.get(pk=project_id)
except models.Project.DoesNotExist:
raise ParseError("Not valid project_id")
template = models.ProjectTemplate(
name=template_name,
slug=template_slug,
description=template_description,
)
template.load_data_from_project(project)
template.save()
return Response(self.serializer_class(template).data, status=201)
def cancel(self):
with advisory_lock("delete-user"):
deleted_user_prefix = "deleted-user-{}".format(timestamp_ms())
self.username = slugify_uniquely(deleted_user_prefix, User, slugfield="username")
self.email = "{}@taiga.io".format(self.username)
self.is_active = False
self.full_name = "Deleted user"
self.color = ""
self.bio = ""
self.lang = ""
self.theme = ""
self.timezone = ""
self.colorize_tags = True
self.token = None
self.set_unusable_password()
self.photo = None
self.save()
self.auth_data.all().delete()
# Blocking all owned projects
self.owned_projects.update(blocked_code=BLOCKED_BY_OWNER_LEAVING)
# Remove all memberships
self.memberships.all().delete()
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify_uniquely(self.name, self.__class__)
super().save(*args, **kwargs)
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify_uniquely(self.name, self.__class__)
super().save(*args, **kwargs)
def ping_federate_register(
username: str,
email: str,
full_name: str,
ping_federate_guid: int,
token: str=None,
):
"""
Register a new user from ping federate.
This can raise `exc.IntegrityError` exceptions in
case of conflics found.
:returns: User
"""
auth_data_model = apps.get_model("users", "AuthData")
user_model = apps.get_model("users", "User")
try:
# Ping federate user association exist?
auth_data = auth_data_model.objects.get(
key=USER_KEY,
value=ping_federate_guid,
)
user = auth_data.user
except auth_data_model.DoesNotExist:
try:
# Is a user with the same email as the google user?
user = user_model.objects.get(email=email)
auth_data_model.objects.create(
user=user,
key=USER_KEY,
value=ping_federate_guid,
extra={}
)
except user_model.DoesNotExist:
# Create a new user
username_unique = slugify_uniquely(
username,
user_model,
slugfield="username"
)
user = user_model.objects.create(
email=email,
username=username_unique,
full_name=full_name,
)
auth_data_model.objects.create(
user=user,
key=USER_KEY,
value=ping_federate_guid,
extra={}
)
send_register_email(user)
user_registered_signal.send(
sender=user.__class__,
user=user
)
if token:
membership = get_membership_by_token(token)
membership.user = user
membership.save(update_fields=["user"])
return user
