def retrieve(request: HttpRequest, *args, **kwargs) -> HttpResponse:
"""Retrieve an account."""
account_viewset = AccountsViewSet.init("retrieve", request, args, kwargs)
account = account_viewset.get_object()
# Show projects that the request user has read access to, and
# - for personal accounts, that the account user is a member of
# - for organizational accounts, only those owned by the account
# ie. will only show private projects if the request user has access to it
projects_viewset = ProjectsViewSet.init("retrieve", request, args, kwargs)
projects = projects_viewset.get_queryset()
if account.is_personal:
projects = projects.filter(agents__user=account.user_id)
else:
projects = projects.filter(account=account)
return render(
request,
"accounts/retrieve.html",
dict(
account=account,
role=account.role,
projects=projects,
meta=account.get_meta(),
),
)
def plan(request: HttpRequest, *args, **kwargs) -> HttpResponse:
"""
Get the account usage relative to current and other plans.
This uses the `update_plan` action to check permission: although
this view does not change the plan, we only want MANAGER or OWNER
to see usage etc.
"""
viewset = AccountsViewSet.init("update_plan", request, args, kwargs)
account = viewset.get_object()
usage = AccountQuotas.usage(account)
tiers = AccountTier.active_tiers()
fields = AccountTier.fields()
return render(
request,
"accounts/plan.html",
dict(
account=account,
role=account.role,
usage=usage,
tier=account.tier,
tiers=tiers,
fields=fields,
),
)
def list_users(request: HttpRequest, *args, **kwargs) -> HttpResponse:
"""
List personal accounts as "/users".
Filters the default queryset to only include personal accounts.
"""
viewset = AccountsViewSet.init("list", request, args, kwargs)
accounts = viewset.get_queryset().filter(user__isnull=False)
return render(request, "accounts/list_users.html", dict(accounts=accounts))
def publishing(request: HttpRequest, *args, **kwargs) -> HttpResponse:
"""Update an account publishing settings."""
viewset = AccountsViewSet.init("partial_update", request, args, kwargs)
account = viewset.get_object()
serializer = viewset.get_serializer(account)
return render(
request,
"accounts/publishing.html",
dict(account=account, role=account.role, serializer=serializer),
)
def redirect(request: HttpRequest, *args, **kwargs) -> HttpResponse:
"""
Redirect from an account `id` URL to an account `name` URL.
For instances where we need to redirect to the account using `id`
(e.g. because its name may have changed in a form).
This uses `get_object` to ensure the same access control applies
to the redirect.
"""
viewset = AccountsViewSet.init("retrieve", request, args, kwargs)
account = viewset.get_object()
return redir("/{0}{1}".format(account.name, kwargs["rest"]))
def billing(request: HttpRequest, *args, **kwargs) -> HttpResponse:
"""
Allow users to manage their billing.
Currently implemented as a redirect to Stripe Customer Portal
(https://stripe.com/docs/billing/subscriptions/customer-portal).
Creates a new `account.customer` if necessary and then redirects
them to a portal session.
"""
viewset = AccountsViewSet.init("update_plan", request, args, kwargs)
account = viewset.get_object()
session = account.get_customer_portal_session(request)
return redir(session.url)
def profile(request: HttpRequest, *args, **kwargs) -> HttpResponse:
"""Update an account profile."""
viewset = AccountsViewSet.init("partial_update", request, args, kwargs)
account = viewset.get_object()
serializer = viewset.get_serializer(account)
update_image_form = AccountImageForm()
return render(
request,
"accounts/profile.html",
dict(
account=account,
role=account.role,
serializer=serializer,
update_image_form=update_image_form,
),
)
def profile_image(request: HttpRequest, *args, **kwargs) -> HttpResponse:
"""
Update an account's profile image.
Also updates the cached URL of the user's image in the session storage.
See the `session_storage` middleware for how this is set initially.
"""
if request.method == "POST":
viewset = AccountsViewSet.init("partial_update", request, args, kwargs)
account = viewset.get_object()
form = AccountImageForm(request.POST, request.FILES, instance=account)
if form.is_valid():
form.save()
if account.is_personal:
if request.session and "user" in request.session:
request.session["user"][
"image"] = request.user.personal_account.image.medium
request.session.modified = True
return redir("ui-accounts-profile", account.name)
raise RuntimeError("Error attempting to save the account image.")
else:
raise Http404
def create(request: HttpRequest, *args, **kwargs) -> HttpResponse:
"""Create an account."""
viewset = AccountsViewSet.init("create", request, args, kwargs)
serializer = viewset.get_serializer()
return render(request, "accounts/create.html", dict(serializer=serializer))