from django.http import HttpResponse from rest_framework import viewsets from rest_framework.decorators import detail_route from orchestra.api import router, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from orchestra.utils.html import html_to_pdf from .models import Bill from .serializers import BillSerializer class BillViewSet(LogApiMixin, AccountApiMixin, viewsets.ModelViewSet): queryset = Bill.objects.all() serializer_class = BillSerializer @detail_route(methods=['get']) def document(self, request, pk): bill = self.get_object() content_type = request.META.get('HTTP_ACCEPT') if content_type == 'application/pdf': pdf = html_to_pdf(bill.html or bill.render()) return HttpResponse(pdf, content_type='application/pdf') else: return HttpResponse(bill.html or bill.render()) router.register('bills', BillViewSet)
from rest_framework import viewsets from orchestra.api import router, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from .models import Contact from .serializers import ContactSerializer class ContactViewSet(LogApiMixin, AccountApiMixin, viewsets.ModelViewSet): model = Contact serializer_class = ContactSerializer router.register(r'contacts', ContactViewSet)
from .serializers import DomainSerializer class DomainViewSet(AccountApiMixin, viewsets.ModelViewSet): serializer_class = DomainSerializer filter_fields = ('name', ) queryset = Domain.objects.all() def get_queryset(self): qs = super(DomainViewSet, self).get_queryset() return qs.prefetch_related('records') @action(detail=True) def view_zone(self, request, pk=None): domain = self.get_object() return Response({'zone': domain.render_zone()}) def options(self, request): metadata = super(DomainViewSet, self).options(request) names = [ 'DOMAINS_DEFAULT_A', 'DOMAINS_DEFAULT_MX', 'DOMAINS_DEFAULT_NS' ] metadata.data['settings'] = { name.lower(): getattr(settings, name, None) for name in names } return metadata router.register(r'domains', DomainViewSet)
from rest_framework import viewsets from orchestra.api import router, SetPasswordApiMixin, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from .models import List from .serializers import ListSerializer class ListViewSet(LogApiMixin, AccountApiMixin, SetPasswordApiMixin, viewsets.ModelViewSet): queryset = List.objects.all() serializer_class = ListSerializer filter_fields = ('name',) router.register(r'lists', ListViewSet)
from rest_framework import viewsets from orchestra.api import router from orchestra.apps.accounts.api import AccountApiMixin from .models import Bill from .serializers import BillSerializer class BillViewSet(AccountApiMixin, viewsets.ModelViewSet): model = Bill serializer_class = BillSerializer router.register(r'bills', BillViewSet)
from rest_framework import viewsets from orchestra.api import router from orchestra.contrib.accounts.api import AccountApiMixin from .models import Order from .serializers import OrderSerializer class OrderViewSet(AccountApiMixin, viewsets.ModelViewSet): queryset = Order.objects.all() serializer_class = OrderSerializer router.register(r'orders', OrderViewSet)
from rest_framework import viewsets from orchestra.api import router, SetPasswordApiMixin, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from .models import Address, Mailbox from .serializers import AddressSerializer, MailboxSerializer class AddressViewSet(LogApiMixin, AccountApiMixin, viewsets.ModelViewSet): queryset = Address.objects.select_related('domain').prefetch_related('mailboxes').all() serializer_class = AddressSerializer filter_fields = ('domain', 'mailboxes__name') class MailboxViewSet(LogApiMixin, SetPasswordApiMixin, AccountApiMixin, viewsets.ModelViewSet): queryset = Mailbox.objects.prefetch_related('addresses__domain').all() serializer_class = MailboxSerializer router.register(r'mailboxes', MailboxViewSet) router.register(r'addresses', AddressViewSet)
from django.contrib.auth import get_user_model from rest_framework import viewsets from rest_framework import status from rest_framework.decorators import action from rest_framework.response import Response from orchestra.api import router, SetPasswordApiMixin from orchestra.apps.accounts.api import AccountApiMixin from .serializers import UserSerializer class UserViewSet(AccountApiMixin, SetPasswordApiMixin, viewsets.ModelViewSet): model = get_user_model() serializer_class = UserSerializer def get_queryset(self): """ select related roles """ qs = super(UserViewSet, self).get_queryset() return qs.select_related(*self.inserted) router.register(r'users', UserViewSet)
from rest_framework import viewsets from orchestra.api import router from orchestra.apps.accounts.api import AccountApiMixin from .models import Contact, InvoiceContact from .serializers import ContactSerializer, InvoiceContactSerializer class ContactViewSet(AccountApiMixin, viewsets.ModelViewSet): model = Contact serializer_class = ContactSerializer class InvoiceContactViewSet(AccountApiMixin, viewsets.ModelViewSet): model = InvoiceContact serializer_class = InvoiceContactSerializer router.register(r'contacts', ContactViewSet) router.register(r'invoicecontacts', InvoiceContactViewSet)
from orchestra.api import router, SetPasswordApiMixin, LogApiMixin from .models import Account from .serializers import AccountSerializer class AccountApiMixin(object): def get_queryset(self): qs = super(AccountApiMixin, self).get_queryset() return qs.filter(account=self.request.user.pk) class AccountViewSet(LogApiMixin, SetPasswordApiMixin, viewsets.ModelViewSet): queryset = Account.objects.all() serializer_class = AccountSerializer singleton_pk = lambda _,request: request.user.pk def get_queryset(self): qs = super(AccountViewSet, self).get_queryset() return qs.filter(id=self.request.user.pk) def destroy(self, request, pk=None): # TODO reimplement in permissions if not request.user.is_superuser: raise exceptions.PermissionDenied(_("Accounts can not be deleted.")) return super(AccountViewSet, self).destroy(request, pk=pk) router.register(r'accounts', AccountViewSet)
'WEBAPPS_BASE_DIR', 'WEBAPPS_TYPES', 'WEBAPPS_WEBAPP_OPTIONS', 'WEBAPPS_PHP_DISABLED_FUNCTIONS', 'WEBAPPS_DEFAULT_TYPE' ] metadata.data['settings'] = { name.lower(): getattr(settings, name, None) for name in names } # AppTypes meta = self.metadata_class() app_types = {} for app_type in AppType.get_plugins(): if app_type.serializer: data = meta.get_serializer_info(app_type.serializer()) else: data = {} data['option_groups'] = app_type.option_groups app_types[app_type.get_name()] = data metadata.data['actions']['types'] = app_types # Options options = {} for option in AppOption.get_plugins(): options[option.get_name()] = { 'verbose_name': option.get_verbose_name(), 'help_text': option.help_text, 'group': option.group, } metadata.data['actions']['options'] = options return metadata router.register(r'webapps', WebAppViewSet)
from rest_framework import viewsets from orchestra.api import router from .models import MailDomain, Mailbox, MailAlias from .serializers import MailDomainSerializer, MailAliasSerializer class MailDomainViewSet(viewsets.ModelViewSet): model = MailDomain serializer_class = MailDomainSerializer class MailboxViewSet(viewsets.ModelViewSet): model = Mailbox class MailAliasViewSet(viewsets.ModelViewSet): model = MailAlias serializer_class = MailAliasSerializer router.register(r'maildomains', MailDomainViewSet) router.register(r'mailboxes', MailboxViewSet) router.register(r'mailaliases', MailAliasViewSet)
from django.http import HttpResponse from rest_framework import viewsets from rest_framework.decorators import detail_route from orchestra.api import router, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from orchestra.utils.html import html_to_pdf from .models import Bill from .serializers import BillSerializer class BillViewSet(LogApiMixin, AccountApiMixin, viewsets.ModelViewSet): queryset = Bill.objects.all() serializer_class = BillSerializer @detail_route(methods=["get"]) def document(self, request, pk): bill = self.get_object() content_type = request.META.get("HTTP_ACCEPT") if content_type == "application/pdf": pdf = html_to_pdf(bill.html or bill.render()) return HttpResponse(pdf, content_type="application/pdf") else: return HttpResponse(bill.html or bill.render()) router.register("bills", BillViewSet)
from rest_framework import viewsets from orchestra.api import router, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from . import settings from .models import Website from .serializers import WebsiteSerializer class WebsiteViewSet(LogApiMixin, AccountApiMixin, viewsets.ModelViewSet): queryset = Website.objects.prefetch_related('domains', 'content_set__webapp', 'directives').all() serializer_class = WebsiteSerializer filter_fields = ('name', 'domains__name') def options(self, request): metadata = super(WebsiteViewSet, self).options(request) names = ['WEBSITES_OPTIONS', 'WEBSITES_PORT_CHOICES'] metadata.data['settings'] = { name.lower(): getattr(settings, name, None) for name in names } return metadata router.register(r'websites', WebsiteViewSet)
queryset = Ticket.objects.all() serializer_class = TicketSerializer @action(detail=True) def mark_as_read(self, request, pk=None): ticket = self.get_object() ticket.mark_as_read_by(request.user) return Response({'status': 'Ticket marked as read'}) @action(detail=True) def mark_as_unread(self, request, pk=None): ticket = self.get_object() ticket.mark_as_unread_by(request.user) return Response({'status': 'Ticket marked as unread'}) def get_queryset(self): qs = super(TicketViewSet, self).get_queryset() qs = qs.select_related('creator', 'queue') qs = qs.prefetch_related('messages__author') return qs.filter(creator=self.request.user) class QueueViewSet(LogApiMixin, mixins.ListModelMixin, mixins.RetrieveModelMixin, viewsets.GenericViewSet): queryset = Queue.objects.all() serializer_class = QueueSerializer router.register(r'tickets', TicketViewSet) router.register(r'ticket-queues', QueueViewSet)
from orchestra.api import router, SetPasswordApiMixin, LogApiMixin from .models import Account from .serializers import AccountSerializer class AccountApiMixin(object): def get_queryset(self): qs = super(AccountApiMixin, self).get_queryset() return qs.filter(account=self.request.user.pk) class AccountViewSet(LogApiMixin, SetPasswordApiMixin, viewsets.ModelViewSet): queryset = Account.objects.all() serializer_class = AccountSerializer singleton_pk = lambda _, request: request.user.pk def get_queryset(self): qs = super(AccountViewSet, self).get_queryset() return qs.filter(id=self.request.user.pk) def destroy(self, request, pk=None): # TODO reimplement in permissions if not request.user.is_superuser: raise exceptions.PermissionDenied( _("Accounts can not be deleted.")) return super(AccountViewSet, self).destroy(request, pk=pk) router.register(r'accounts', AccountViewSet)
from rest_framework import viewsets from orchestra.api import router, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from .models import PaymentSource, Transaction from .serializers import PaymentSourceSerializer, TransactionSerializer class PaymentSourceViewSet(LogApiMixin, AccountApiMixin, viewsets.ModelViewSet): serializer_class = PaymentSourceSerializer queryset = PaymentSource.objects.all() class TransactionViewSet(LogApiMixin, viewsets.ModelViewSet): serializer_class = TransactionSerializer queryset = Transaction.objects.all() router.register(r'payment-sources', PaymentSourceViewSet) router.register(r'transactions', TransactionViewSet)
from rest_framework import viewsets from orchestra.api import router, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from .models import Contact from .serializers import ContactSerializer class ContactViewSet(LogApiMixin, AccountApiMixin, viewsets.ModelViewSet): queryset = Contact.objects.all() serializer_class = ContactSerializer router.register(r'contacts', ContactViewSet)
@action() def mark_as_read(self, request, pk=None): ticket = self.get_object() ticket.mark_as_read_by(request.user) return Response({'status': 'Ticket marked as read'}) @action() def mark_as_unread(self, request, pk=None): ticket = self.get_object() ticket.mark_as_unread_by(request.user) return Response({'status': 'Ticket marked as unread'}) def get_queryset(self): qs = super(TicketViewSet, self).get_queryset() qs = qs.select_related('creator', 'queue') qs = qs.prefetch_related('messages__author') return qs.filter(creator=self.request.user) class QueueViewSet(LogApiMixin, mixins.ListModelMixin, mixins.RetrieveModelMixin, viewsets.GenericViewSet): model = Queue serializer_class = QueueSerializer router.register(r'tickets', TicketViewSet) router.register(r'ticket-queues', QueueViewSet)
from rest_framework import viewsets from orchestra.api import router, SetPasswordApiMixin, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from .models import Database, DatabaseUser from .serializers import DatabaseSerializer, DatabaseUserSerializer class DatabaseViewSet(LogApiMixin, AccountApiMixin, viewsets.ModelViewSet): model = Database serializer_class = DatabaseSerializer filter_fields = ('name',) class DatabaseUserViewSet(LogApiMixin, AccountApiMixin, SetPasswordApiMixin, viewsets.ModelViewSet): model = DatabaseUser serializer_class = DatabaseUserSerializer filter_fields = ('username',) router.register(r'databases', DatabaseViewSet) router.register(r'databaseusers', DatabaseUserViewSet)
from rest_framework import viewsets from orchestra.api import router from orchestra.contrib.accounts.api import AccountApiMixin from .models import Order from .serializers import OrderSerializer class OrderViewSet(AccountApiMixin, viewsets.ModelViewSet): model = Order serializer_class = OrderSerializer router.register(r'orders', OrderViewSet)
from rest_framework import viewsets from orchestra.api import router, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from .models import SaaS from .serializers import SaaSSerializer class SaaSViewSet(LogApiMixin, AccountApiMixin, viewsets.ModelViewSet): queryset = SaaS.objects.all() serializer_class = SaaSSerializer filter_fields = ('name', ) router.register(r'saas', SaaSViewSet)
from .models import Domain from .serializers import DomainSerializer class DomainViewSet(AccountApiMixin, viewsets.ModelViewSet): model = Domain serializer_class = DomainSerializer filter_fields = ('name',) def get_queryset(self): qs = super(DomainViewSet, self).get_queryset() return qs.prefetch_related('records') @link() def view_zone(self, request, pk=None): domain = self.get_object() return Response({ 'zone': domain.render_zone() }) def metadata(self, request): ret = super(DomainViewSet, self).metadata(request) names = ['DOMAINS_DEFAULT_A', 'DOMAINS_DEFAULT_MX', 'DOMAINS_DEFAULT_NS'] ret['settings'] = { name.lower(): getattr(settings, name, None) for name in names } return ret router.register(r'domains', DomainViewSet)
from django.utils.translation import ugettext_lazy as _ from rest_framework import viewsets, exceptions from orchestra.api import router, SetPasswordApiMixin, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from .models import SystemUser from .serializers import SystemUserSerializer class SystemUserViewSet(LogApiMixin, AccountApiMixin, SetPasswordApiMixin, viewsets.ModelViewSet): model = SystemUser serializer_class = SystemUserSerializer filter_fields = ('username',) def destroy(self, request, pk=None): user = self.get_object() if user.is_main: raise exceptions.PermissionDenied(_("Main system user can not be deleted.")) return super(SystemUserViewSet, self).destroy(request, pk=pk) router.register(r'systemusers', SystemUserViewSet)
from rest_framework import viewsets from orchestra.api import router, SetPasswordApiMixin, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from .models import List from .serializers import ListSerializer class ListViewSet(LogApiMixin, AccountApiMixin, SetPasswordApiMixin, viewsets.ModelViewSet): model = List serializer_class = ListSerializer filter_fields = ('name',) router.register(r'lists', ListViewSet)
from rest_framework import viewsets from orchestra.api import router from orchestra.apps.accounts.api import AccountApiMixin from .models import PaymentSource, Transaction from .serializers import PaymentSourceSerializer, TransactionSerializer class PaymentSourceViewSet(AccountApiMixin, viewsets.ModelViewSet): model = PaymentSource serializer_class = PaymentSourceSerializer class TransactionViewSet(viewsets.ModelViewSet): model = Transaction serializer_class = TransactionSerializer router.register(r'payment-sources', PaymentSourceViewSet) router.register(r'transactions', TransactionViewSet)
from rest_framework import viewsets from orchestra.api import router, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from . import settings from .models import Website from .serializers import WebsiteSerializer class WebsiteViewSet(LogApiMixin, AccountApiMixin, viewsets.ModelViewSet): model = Website serializer_class = WebsiteSerializer filter_fields = ('name',) def metadata(self, request): ret = super(WebsiteViewSet, self).metadata(request) names = ['WEBSITES_OPTIONS', 'WEBSITES_PORT_CHOICES'] ret['settings'] = { name.lower(): getattr(settings, name, None) for name in names } return ret router.register(r'websites', WebsiteViewSet)
from rest_framework import viewsets from orchestra.api import router, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from .models import SaaS from .serializers import SaaSSerializer class SaaSViewSet(LogApiMixin, AccountApiMixin, viewsets.ModelViewSet): queryset = SaaS.objects.all() serializer_class = SaaSSerializer filter_fields = ('name',) router.register(r'saas', SaaSViewSet)
from django.utils.translation import ugettext_lazy as _ from rest_framework import viewsets, exceptions from orchestra.api import router, SetPasswordApiMixin, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from .models import SystemUser from .serializers import SystemUserSerializer class SystemUserViewSet(LogApiMixin, AccountApiMixin, SetPasswordApiMixin, viewsets.ModelViewSet): queryset = SystemUser.objects.all() serializer_class = SystemUserSerializer filter_fields = ('username', ) def destroy(self, request, pk=None): user = self.get_object() if user.is_main: raise exceptions.PermissionDenied( _("Main system user can not be deleted.")) return super(SystemUserViewSet, self).destroy(request, pk=pk) router.register(r'systemusers', SystemUserViewSet)
from rest_framework import viewsets from orchestra.api import router, SetPasswordApiMixin, LogApiMixin from orchestra.contrib.accounts.api import AccountApiMixin from .models import Database, DatabaseUser from .serializers import DatabaseSerializer, DatabaseUserSerializer class DatabaseViewSet(LogApiMixin, AccountApiMixin, viewsets.ModelViewSet): queryset = Database.objects.prefetch_related('users').all() serializer_class = DatabaseSerializer filter_fields = ('name', ) class DatabaseUserViewSet(LogApiMixin, AccountApiMixin, SetPasswordApiMixin, viewsets.ModelViewSet): queryset = DatabaseUser.objects.prefetch_related('databases').all() serializer_class = DatabaseUserSerializer filter_fields = ('username', ) router.register(r'databases', DatabaseViewSet) router.register(r'databaseusers', DatabaseUserViewSet)
from rest_framework import viewsets from rest_framework.decorators import action from rest_framework.response import Response from orchestra.api import router, list_link from . import settings from .models import Zone from .serializers import ZoneSerializer class ZoneViewSet(viewsets.ModelViewSet): model = Zone serializer_class = ZoneSerializer @action() def reload(self, request, pk=None): pass @list_link() def configuration(self, request): return Response({ 'DNS_ZONE_DEFAULT_RECORDS': settings.DNS_ZONE_DEFAULT_RECORDS }) router.register(r'zones', ZoneViewSet)
from rest_framework import viewsets from rest_framework.decorators import action from orchestra.api import router from .models import Web from .serializers import WebSerializer class WebViewSet(viewsets.ModelViewSet): model = Web serializer_class = WebSerializer @action() def reload(self, request, pk=None): pass router.register(r'webs', WebViewSet)
from rest_framework import viewsets from rest_framework.response import Response from orchestra.api import router from orchestra.apps.accounts.api import AccountApiMixin from . import settings from .models import WebApp from .serializers import WebAppSerializer class WebAppViewSet(AccountApiMixin, viewsets.ModelViewSet): model = WebApp serializer_class = WebAppSerializer filter_fields = ('name',) def metadata(self, request): ret = super(WebAppViewSet, self).metadata(request) names = [ 'WEBAPPS_BASE_ROOT', 'WEBAPPS_TYPES', 'WEBAPPS_WEBAPP_OPTIONS', 'WEBAPPS_PHP_DISABLED_FUNCTIONS', 'WEBAPPS_DEFAULT_TYPE' ] ret['settings'] = { name.lower(): getattr(settings, name, None) for name in names } return ret router.register(r'webapps', WebAppViewSet)
from rest_framework import viewsets from orchestra.api import router from .models import Server from .serializers import ServerSerializer class ServerViewSet(viewsets.ModelViewSet): model = Server serializer_class = ServerSerializer router.register(r'servers', ServerViewSet)