def project_authorization(sender, instance, created, **kwargs):
if instance.role is not ProjectRoleLevel.NOTHING.value:
instance_user = (instance.organization_authorization.organization.
get_user_authorization(instance.user))
opened = OpenedProject.objects.filter(project=instance.project,
user=instance.user)
if not opened.exists():
OpenedProject.objects.create(user=instance.user,
project=instance.project,
day=instance.project.created_at)
else:
opened = opened.first()
opened.day = timezone.now()
opened.save()
if instance_user.level == OrganizationLevelRole.NOTHING.value:
instance_user.role = OrganizationRole.VIEWER.value
instance_user.save(update_fields=["role"])
celery_app.send_task(
"update_user_permission_project",
args=[
instance.project.flow_organization,
instance.project.uuid,
instance.user.email,
instance.role,
],
)
def check_organization_free_plan():
limits = GenericBillingData.get_generic_billing_data_instance()
flow_instance = utils.get_grpc_types().get("flow")
for organization in Organization.objects.filter(
organization_billing__plan="free", is_suspended=False):
for project in organization.project.all():
project_timezone = project.timezone
now = pendulum.now(project_timezone)
before = now.strftime("%Y-%m-%d %H:%M")
# first day of month
after = now.start_of('month').strftime("%Y-%m-%d %H:%M")
contact_count = flow_instance.get_billing_total_statistics(
project_uuid=str(project.flow_organization),
before=before,
after=after).get("active_contacts")
project.contact_count = int(contact_count)
project.save(update_fields=["contact_count"])
current_active_contacts = organization.active_contacts
if current_active_contacts > limits.free_active_contacts_limit:
organization.is_suspended = True
for project in organization.project.all():
app.send_task(
"update_suspend_project",
args=[str(project.flow_organization), True],
)
organization.save(update_fields=["is_suspended"])
organization.organization_billing.send_email_expired_free_plan(
organization.name,
organization.authorizations.values_list("user__email",
flat=True),
)
return True
def update(self, instance, validated_data):
name = validated_data.get("name", instance.name)
celery_app.send_task(
"update_project",
args=[instance.flow_organization, name],
)
return super().update(instance, validated_data)
def reactivate_plan(self, request, organization_uuid): # pragma: no cover
organization = get_object_or_404(Organization, uuid=organization_uuid)
self.check_object_permissions(self.request, organization)
org_billing = organization.organization_billing
org_billing.termination_date = None
org_billing.is_active = True
org_billing.contract_on = timezone.now().date()
org_billing.save()
for project in organization.project.all():
celery_app.send_task(
"update_suspend_project",
args=[str(project.flow_organization), False],
)
user_name = (org_billing.organization.name
if request.user is None else request.user.first_name)
org_billing.send_email_reactivated_plan(
user_name,
organization.authorizations.values_list("user__email", flat=True))
result = {
"plan": org_billing.plan,
"is_active": org_billing.is_active,
"termination_date": org_billing.termination_date,
"contract_on": org_billing.contract_on,
}
return JsonResponse(data=result, status=status.HTTP_200_OK)
def perform_destroy(self, instance):
flow_organization = instance.flow_organization
instance.delete()
celery_app.send_task(
"delete_project",
args=[flow_organization, self.request.user.email],
)
def update_organization(instance, **kwargs):
for project in instance.project.all():
celery_app.send_task( # pragma: no cover
name="update_suspend_project",
args=[
str(project.flow_organization),
instance.is_suspended,
],
)
def perform_project_authorization_destroy(self, instance,
is_request_permission):
flow_organization = instance.project.flow_organization
if not is_request_permission:
celery_app.send_task(
"delete_user_permission_project",
args=[flow_organization, instance.user.email, instance.role],
)
instance.delete()
def change_language(self, request, **kwargs): # pragma: no cover
serializer = ChangeLanguageSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = request.user
user.language = serializer.data.get("language")
user.save(update_fields=["language"])
celery_app.send_task(
"update_user_language",
args=[
user.email,
user.language,
],
)
return Response({"language": user.language})
def create_service_status(sender, instance, created, **kwargs):
if created:
for service in Service.objects.filter(default=True):
instance.service_status.create(service=service)
for permission in instance.project_authorizations.all():
celery_app.send_task(
"update_user_permission_project",
args=[
instance.flow_organization,
instance.uuid,
permission.user.email,
permission.role,
],
)
for authorization in instance.organization.authorizations.all():
if authorization.can_contribute:
project_auth = instance.get_user_authorization(
authorization.user)
project_auth.role = authorization.role
project_auth.save()
def upload_photo(self, request, **kwargs): # pragma: no cover
file = request.FILES.get("file")
serializer = UserPhotoSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
if filetype.is_image(file):
user = self.request.user
user.photo = file
user.save(update_fields=["photo"])
# Update avatar on integrations
celery_app.send_task("update_user_photo",
args=[user.email,
self._get_photo_url(user)])
# Update avatar in all rocket chat registered
for authorization in user.authorizations_user.all():
for project in authorization.organization.project.all():
for service_status in project.service_status.filter(
service__service_type=Service.SERVICE_TYPE_CHAT):
upload_photo_rocket(
server_rocket=service_status.service.url,
jwt_token=self.request.auth,
avatar_url=user.photo.url,
)
return Response({"photo": user.photo.url})
try:
raise UnsupportedMediaType(
filetype.get_type(file.content_type).extension,
detail=_(
"We accept images only in the formats: .png, .jpeg, .gif"),
)
except Exception:
raise UnsupportedMediaType(
None,
detail=_(
"We accept images only in the formats: .png, .jpeg, .gif"),
)
def create_user(self, claims):
# Override existing create_user method in OIDCAuthenticationBackend
email = claims.get("email")
username = self.get_username(claims)
user = self.UserModel.objects.create_user(email, username)
old_username = user.username
user.username = claims.get("preferred_username", old_username)
user.first_name = claims.get("given_name", "")
user.last_name = claims.get("family_name", "")
user.email = claims.get("email", "")
user.save()
check_module_permission(claims, user)
if settings.SYNC_ORGANIZATION_INTELIGENCE:
task = celery_app.send_task( # pragma: no cover
name="migrate_organization",
args=[str(user.email)],
)
task.wait() # pragma: no cover
return user
def project_search(self, request, **kwargs): # pragma: no cover
serializer = ProjectSearchSerializer(data=request.query_params)
serializer.is_valid(raise_exception=True)
project = Project.objects.get(pk=serializer.data.get("project_uuid"))
user_authorization = project.organization.get_user_authorization(
self.request.user)
if not user_authorization.can_contribute:
raise PermissionDenied(
_("You can't contribute in this organization")
) # pragma: no cover
task = celery_app.send_task( # pragma: no cover
name="search_project",
args=[
project.organization.inteligence_organization,
str(project.flow_organization),
serializer.data.get("text"),
],
)
task.wait() # pragma: no cover
return Response(task.result)
