def insert_resource_serializers():
# clean previous state
for related in Resource._related:
try:
viewset = router.get_viewset(related)
except KeyError:
# API viewset not registered
pass
else:
fields = list(viewset.serializer_class.Meta.fields)
try:
fields.remove('resources')
except ValueError:
pass
viewset.serializer_class.Meta.fields = fields
# Create nested serializers on target models
for ct, resources in Resource.objects.group_by('content_type').items():
model = ct.model_class()
try:
router.insert(model, 'resources', ResourceSerializer, required=False, many=True, source='resource_set')
except KeyError:
continue
# TODO this is a f*****g workaround, reimplement this on the proper place
def validate_resources(self, posted, _resources=resources):
""" Creates missing resources """
result = []
resources = list(_resources)
for data in posted:
resource = data.resource
if resource not in resources:
msg = "Unknown or duplicated resource '%s'." % resource
raise serializers.ValidationError(msg)
resources.remove(resource)
if not resource.on_demand and not data.allocated:
data.allocated = resource.default_allocation
result.append(data)
for resource in resources:
data = ResourceData(resource=resource)
if not resource.on_demand:
data.allocated = resource.default_allocation
result.append(data)
return result
viewset = router.get_viewset(model)
viewset.serializer_class.validate_resources = validate_resources
old_options = viewset.options
def options(self, request, resources=resources):
""" Provides available resources description """
metadata = old_options(self, request)
metadata.data['available_resources'] = [
{
'name': resource.name,
'on_demand': resource.on_demand,
'default_allocation': resource.default_allocation
} for resource in resources
]
return metadata
viewset.options = options
from rest_framework import serializers
from orchestra.api import router
from .models import WebDatabase
class WebDatabaseSerializer(serializers.ModelSerializer):
class Meta:
model = WebDatabase
fields = ('name', 'username', 'password', 'type')
router.insert(r'webs', 'webdatabases', WebDatabaseSerializer, many=True)
class NestedMailboxSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = Mailbox
fields = ('url', 'use_custom_filtering', 'custom_filtering')
class MailboxSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = Mailbox
fields = ('url', 'user', 'use_custom_filtering', 'custom_filtering')
class AddressSerializer(AccountSerializerMixin, serializers.HyperlinkedModelSerializer):
class Meta:
model = Address
fields = ('url', 'name', 'domain', 'mailboxes', 'forward')
def get_fields(self, *args, **kwargs):
fields = super(AddressSerializer, self).get_fields(*args, **kwargs)
account = self.context['view'].request.user.account_id
mailboxes = fields['mailboxes'].queryset.select_related('user')
fields['mailboxes'].queryset = mailboxes.filter(user__account=account)
# TODO do it on permissions or in self.filter_by_account_field ?
domain = fields['domain'].queryset
fields['domain'].queryset = domain .filter(account=account)
return fields
router.insert('users', 'mailbox', NestedMailboxSerializer, required=False)
def get_name(self, instance):
return instance.resource.name
def get_identity(self, data):
return data.get('name')
# Monkey-patching section
if not running_syncdb():
# TODO why this is even loaded during syncdb?
# Create nested serializers on target models
for ct, resources in Resource.objects.group_by('content_type'):
model = ct.model_class()
try:
router.insert(model, 'resources', ResourceSerializer, required=False, many=True, source='resource_set')
except KeyError:
continue
def validate_resources(self, attrs, source, _resources=resources):
""" Creates missing resources """
posted = attrs.get(source, [])
result = []
resources = list(_resources)
for data in posted:
resource = data.resource
if resource not in resources:
msg = "Unknown or duplicated resource '%s'." % resource
raise serializers.ValidationError(msg)
resources.remove(resource)
if not resource.ondemand and not data.allocated:
from orchestra.contrib.accounts.serializers import AccountSerializerMixin
from .models import Bill, BillLine, BillContact
class BillLineSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = BillLine
class BillSerializer(AccountSerializerMixin, serializers.HyperlinkedModelSerializer):
# lines = BillLineSerializer(source='lines')
class Meta:
model = Bill
fields = (
'url', 'id', 'number', 'type', 'total', 'is_sent', 'created_on', 'due_on',
'comments',
# 'lines'
)
class BillContactSerializer(AccountSerializerMixin, serializers.ModelSerializer):
class Meta:
model = BillContact
fields = ('name', 'address', 'city', 'zipcode', 'country', 'vat')
router.insert(Account, 'billcontact', BillContactSerializer, required=False)
from rest_framework import serializers
from orchestra.api import router
from .models import WebFTPAccount
class WebFTPAccountSerializer(serializers.ModelSerializer):
class Meta:
model = WebFTPAccount
fields = ('username', 'password', 'directory')
router.insert(r'webs', 'webftpaccounts', WebFTPAccountSerializer, many=True)
from rest_framework import serializers
from orchestra.api import router
from .models import POSIX
class POSIXSerializer(serializers.ModelSerializer):
class Meta:
model = POSIX
fields = ('home', 'shell')
router.insert('users', 'posix', POSIXSerializer, required=False)
