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)
