class Meta:
_serializer_class = 'vstutils.api.serializers.VSTSerializer'
_list_fields = ('name', 'local_filter_applied', 'filter_applied',
'string_filter_applied')
_override_list_fields = {
'id':
fields.RedirectIntegerField(read_only=True,
operation_name='files'),
'name':
fields.DependEnumField(field='id', choices={
3: 'hello',
1: 'NOO!'
}),
'local_filter_applied':
fields.IntegerField(default=0, read_only=True),
'filter_applied':
fields.IntegerField(default=0, read_only=True),
'string_filter_applied':
DrfBooleanField(default=False, read_only=True)
}
_extra_serializer_classes = {
'serializer_class_test': serializers.EmptySerializer
}
_filterset_fields = ('id', 'name')
_filter_backends = (TestFilterBackend,
'test_proj.models.hosts.TestStringFilterBackend')
class ProjectTemplateCreateSerializer(vst_serializers.VSTSerializer):
project_id = vst_fields.RedirectIntegerField(read_only=True,
default=None,
allow_null=True)
name = serializers.CharField(required=False)
class Meta:
model = models.ProjectTemplate
fields = (
'project_id',
'name',
)
def update(self, instance: models.ProjectTemplate,
validated_data) -> models.Project:
validated_data['name'] = validated_data.get(
'name', '{} {}'.format(instance.name, uuid.uuid1()))
data = dict(
name=validated_data['name'],
repository=instance.repository,
type=instance.type,
repo_auth=instance.repo_auth,
auth_data=instance.auth_data or '',
)
serializer = ProjectCreateMasterSerializer(data=data,
context=self.context)
serializer.is_valid(raise_exception=True)
serializer.save()
return serializer.instance
def to_representation(self, instance: models.Project) -> Dict:
return {'name': instance.name, 'project_id': instance.id}
class HostSerializer(VSTSerializer):
id = fields.RedirectIntegerField(read_only=True)
name = fields.DependEnumField(field='id', choices={ 3: 'hello', 1: 'NOO!' })
class Meta:
model = Host
fields = (
'id',
'name',
)
class InventoryImportSerializer(serializers.Serializer):
# pylint: disable=abstract-method
inventory_id = vst_fields.RedirectIntegerField(default=None,
allow_null=True,
read_only=True)
name = serializers.CharField(required=True)
raw_data = vst_fields.VSTCharField()
def create(self, validated_data: Dict) -> Dict:
return models.Inventory.import_inventory_from_string(**validated_data)
def to_representation(self, instance):
return dict(inventory_id=instance.id,
name=instance.name,
raw_data=getattr(instance, 'raw_data', ''))
class InventoryImportSerializer(DataSerializer):
inventory_id = vst_fields.RedirectIntegerField(default=None,
allow_null=True)
name = serializers.CharField(required=True)
raw_data = vst_fields.VSTCharField()
@transaction.atomic()
def create(self, validated_data: Dict) -> Dict:
parser = AnsibleInventoryParser()
inv_json = parser.get_inventory_data(validated_data['raw_data'])
inventory = models.Inventory.objects.create(
name=validated_data['name'])
inventory.vars = inv_json['vars']
created_hosts, created_groups = dict(), dict()
for host in inv_json['hosts']:
inv_host = inventory.hosts.create(name=host['name'])
inv_host.vars = host['vars']
created_hosts[inv_host.name] = inv_host
for group in inv_json['groups']:
children = not len(group['groups']) == 0
inv_group = inventory.groups.create(name=group['name'],
children=children)
inv_group.vars = group['vars']
created_groups[inv_group.name] = inv_group
for group in inv_json['groups']:
inv_group = created_groups[group['name']]
g_subs = list()
if inv_group.children:
for name in group['groups']:
g_subs.append(created_groups[name])
inv_group.groups.add(*g_subs)
else:
for name in group['hosts']:
g_subs.append(created_hosts[name])
inv_group.hosts.add(*g_subs)
inventory.raw_data = validated_data['raw_data']
return inventory
def to_representation(self, instance):
return dict(inventory_id=instance.id,
name=instance.name,
raw_data=getattr(instance, 'raw_data', ''))
class Meta:
_serializer_class = 'vstutils.api.serializers.VSTSerializer'
_list_fields = (
'id',
'name',
'local_filter_applied',
'filter_applied',
)
_override_list_fields = {
'id':
fields.RedirectIntegerField(read_only=True),
'name':
fields.DependEnumField(field='id', choices={
3: 'hello',
1: 'NOO!'
}),
'local_filter_applied':
fields.IntegerField(default=0, read_only=True),
'filter_applied':
fields.IntegerField(default=0, read_only=True),
}
_filterset_fields = ('id', 'name')
_filter_backends = (TestFilterBackend, )
class ExecuteResponseSerializer(ActionResponseSerializer):
history_id = vst_fields.RedirectIntegerField(default=None, allow_null=True)
executor = serializers.IntegerField(default=None, allow_null=True)
