class ProductSerializer(HyperlinkedModelSerializer):
currency = ChoiceField(choices=CURRENCY_CHOICES,
initial="USD",
required=False)
description = CharField(
initial="not set",
required=False,
allow_blank=True,
style={'base_template': 'textarea.html'},
)
list_price = DecimalField(initial="0.00",
required=False,
allow_null=True,
decimal_places=2,
max_digits=32,
help_text="list price of the element",
validators=[MinValueValidator(0)])
lc_state_sync = BooleanField(
required=False,
initial=False,
read_only=True,
help_text="automatic synchronization of lifecycle states")
product_group = PrimaryKeyRelatedField(many=False,
queryset=ProductGroup.objects.all(),
read_only=False,
required=False,
allow_null=True)
vendor = PrimaryKeyRelatedField(many=False,
queryset=Vendor.objects.all(),
read_only=False,
required=False)
def validate_product_group(self, value):
"""
verify that the product group is associated to the same vendor as the product
"""
if value and self.instance: # check for None type
if value.vendor.name != self.instance.vendor.name:
raise serializers.ValidationError(
"Invalid product group, group and product must be associated to the same vendor"
)
return value
class Meta:
model = Product
fields = (
'id',
'product_id',
'description',
'list_price',
'currency',
'tags',
'vendor',
'product_group',
'url',
'eox_update_time_stamp',
'end_of_sale_date',
'end_of_support_date',
'eol_ext_announcement_date',
'end_of_sw_maintenance_date',
'end_of_routine_failure_analysis',
'end_of_service_contract_renewal',
'end_of_new_service_attachment_date',
'end_of_sec_vuln_supp_date',
'eol_reference_number',
'eol_reference_url',
'lc_state_sync',
'internal_product_id',
'update_timestamp',
'list_price_timestamp',
)
extra_kwargs = {
'url': {
'lookup_field': 'id',
'view_name': 'productdb:products-detail'
}
}
depth = 0
class FingerprintSerializer(ModelSerializer):
"""Serializer for the Fingerprint model."""
# Scan information
report_id = PrimaryKeyRelatedField(queryset=FactCollection.objects.all())
# Common facts
name = CharField(required=False, max_length=256)
os_name = CharField(required=False, max_length=64)
os_release = CharField(required=False, max_length=128)
os_version = CharField(required=False, max_length=64)
infrastructure_type = ChoiceField(
required=False, choices=SystemFingerprint.INFRASTRUCTURE_TYPE)
mac_addresses = CustomJSONField(required=False)
ip_addresses = CustomJSONField(required=False)
cpu_count = IntegerField(required=False, min_value=0)
architecture = CharField(required=False, max_length=64)
# Network scan facts
bios_uuid = CharField(required=False, max_length=36)
subscription_manager_id = CharField(required=False, max_length=36)
cpu_socket_count = IntegerField(required=False, min_value=0)
cpu_core_count = FloatField(required=False, min_value=0)
system_creation_date = DateField(required=False)
virtualized_type = CharField(required=False, max_length=64)
# VCenter scan facts
vm_state = CharField(required=False, max_length=24)
vm_uuid = CharField(required=False, max_length=36)
vm_dns_name = CharField(required=False, max_length=128)
vm_host = CharField(required=False, max_length=128)
vm_host_socket_count = IntegerField(required=False, min_value=0)
vm_cluster = CharField(required=False, max_length=128)
vm_datacenter = CharField(required=False, max_length=128)
products = ProductSerializer(many=True, allow_null=True, required=False)
entitlements = EntitlementSerializer(many=True,
allow_null=True,
required=False)
# Red Hat facts
is_redhat = NullBooleanField(required=False)
redhat_certs = CharField(required=False, max_length=128)
# pylint: disable=invalid-name
redhat_package_count = IntegerField(required=False, min_value=0)
metadata = CustomJSONField(required=True)
sources = CustomJSONField(required=True)
class Meta:
"""Meta class for FingerprintSerializer."""
model = SystemFingerprint
fields = '__all__'
def create(self, validated_data):
"""Create a system fingerprint."""
products_data = validated_data.pop('products', [])
entitlements_data = validated_data.pop('entitlements', [])
fingerprint = SystemFingerprint.objects.create(**validated_data)
for product_data in products_data:
Product.objects.create(fingerprint=fingerprint, **product_data)
for entitlement_data in entitlements_data:
Entitlement.objects.create(fingerprint=fingerprint,
**entitlement_data)
return fingerprint
class FilterSerializer(Serializer):
activity = ListField(child=ChoiceField(choices=Notebook.ACTIVITY_STATUS),
required=False)
important = BooleanField(required=False)
public = BooleanField(required=False)
class GitSerializer(Serializer):
time = IntegerField(min_value=0,
required=True,
label='Time',
help_text='Point of time to run report.')
url = ChoiceField(
[],
label='Git URL',
default='https://git.openstack.org/openstack/openstack-ansible',
help_text='Please select a git url.')
def __init__(self, *args, **kwargs):
"""Init the serializer with updated list of git urls."""
self.fields['url'].choices = self.git_urls()
super(GitSerializer, self).__init__(*args, **kwargs)
def git_urls(self):
"""Build list of selectable git urls.
:returns: All git urls
:rtype: list
"""
q = ColumnQuery('GitUrl')
q.add_column('GitUrl', 'url', 'url')
q.orderby('url', 'ASC', label='GitUrl')
urls = []
page = 1
pagesize = 1000
page_rows = q.page(page, pagesize)
while (page_rows):
for row in page_rows:
urls.append(row['url'])
page += 1
page_rows = q.page(page, pagesize)
return urls
def form_data(self):
"""Describes web client form associated with this serializer.
:returns: List of dict objects
:rtype: list
"""
return [
{
'name': 'time',
'label': self.fields['time'].label,
'help_text': self.fields['time'].help_text,
'required': self.fields['time'].required,
'component': 'Time',
'many': False
},
{
'name': 'url',
'label': self.fields['url'].label,
'help_text': self.fields['url'].help_text,
'required': self.fields['url'].required,
'default': self.fields['url'].default,
'component': 'Select',
'choices': self.fields['url'].choices
},
]
class SystemFingerprintSerializer(ModelSerializer):
"""Serializer for the Fingerprint model."""
# Common facts
name = CharField(max_length=256, **default_args)
os_name = CharField(max_length=64, **default_args)
os_release = CharField(max_length=128, **default_args)
os_version = CharField(max_length=64, **default_args)
infrastructure_type = ChoiceField(
required=False, choices=SystemFingerprint.INFRASTRUCTURE_TYPE)
cloud_provider = CharField(max_length=16, **default_args)
mac_addresses = CustomJSONField(**default_args)
ip_addresses = CustomJSONField(**default_args)
cpu_count = IntegerField(min_value=0, **default_args)
architecture = CharField(max_length=64, **default_args)
# Network scan facts
bios_uuid = CharField(max_length=36, **default_args)
subscription_manager_id = CharField(max_length=36, **default_args)
cpu_socket_count = IntegerField(min_value=0, **default_args)
cpu_core_count = FloatField(min_value=0, **default_args)
cpu_core_per_socket = IntegerField(min_value=0, **default_args)
cpu_hyperthreading = BooleanField(**default_args)
system_creation_date = DateField(**default_args)
system_last_checkin_date = DateField(**default_args)
system_purpose = JSONField(**default_args)
system_role = CharField(max_length=128, **default_args)
system_addons = JSONField(**default_args)
system_service_level_agreement = CharField(max_length=128, **default_args)
system_usage_type = CharField(max_length=128, **default_args)
insights_client_id = CharField(max_length=128, **default_args)
virtualized_type = CharField(max_length=64, **default_args)
system_user_count = IntegerField(min_value=0, **default_args)
user_login_history = CustomJSONField(**default_args)
# VCenter scan facts
vm_state = CharField(max_length=24, **default_args)
vm_uuid = CharField(max_length=36, **default_args)
vm_dns_name = CharField(max_length=256, **default_args)
virtual_host_name = CharField(max_length=128, **default_args)
virtual_host_uuid = CharField(max_length=36, **default_args)
vm_host_socket_count = IntegerField(min_value=0, **default_args)
vm_host_core_count = IntegerField(min_value=0, **default_args)
vm_cluster = CharField(max_length=128, **default_args)
vm_datacenter = CharField(max_length=128, **default_args)
products = ProductSerializer(many=True, **default_args)
entitlements = EntitlementSerializer(many=True, **default_args)
# Red Hat facts
is_redhat = BooleanField(**default_args)
redhat_certs = CharField(**default_args)
# pylint: disable=invalid-name
redhat_package_count = IntegerField(min_value=0, **default_args)
metadata = CustomJSONField(required=True)
sources = CustomJSONField(required=True)
etc_machine_id = CharField(max_length=48, **default_args)
class Meta:
"""Meta class for SystemFingerprintSerializer."""
model = SystemFingerprint
fields = '__all__'
def create(self, validated_data):
"""Create a system fingerprint."""
products_data = validated_data.pop('products', [])
entitlements_data = validated_data.pop('entitlements', [])
fingerprint = SystemFingerprint.objects.create(**validated_data)
for product_data in products_data:
Product.objects.create(fingerprint=fingerprint,
**product_data)
for entitlement_data in entitlements_data:
Entitlement.objects.create(fingerprint=fingerprint,
**entitlement_data)
return fingerprint
class ReportTypeSerializer(Serializer):
type = ChoiceField(choices=Report.REPORT_TYPE)
def _get_fields_from_survey(self):
fields = {}
for survey_filed in self.survey["spec"]:
if survey_filed["type"] == "text":
fields[survey_filed['variable']] = CharField(
label=survey_filed['question_name'],
initial=survey_filed['default'],
required=False if self.read_only_form else survey_filed['required'],
help_text=survey_filed['question_description'],
min_length=survey_filed['min'],
max_length=survey_filed['max']
)
elif survey_filed["type"] == "textarea":
fields[survey_filed['variable']] = CharField(
label=survey_filed['question_name'],
initial=survey_filed['default'],
required=False if self.read_only_form else survey_filed['required'],
help_text=survey_filed['question_description'],
min_length=survey_filed['min'],
max_length=survey_filed['max']
)
elif survey_filed["type"] == "password":
fields[survey_filed['variable']] = CharField(
label=survey_filed['question_name'],
required=False if self.read_only_form else survey_filed['required'],
help_text=survey_filed['question_description'],
min_length=survey_filed['min'],
max_length=survey_filed['max'],
)
elif survey_filed["type"] == "multiplechoice":
fields[survey_filed['variable']] = ChoiceField(
label=survey_filed['question_name'],
initial=survey_filed['default'],
required=False if self.read_only_form else survey_filed['required'],
help_text=survey_filed['question_description'],
choices=get_choices_from_string(survey_filed["choices"]),
error_messages={'required': 'At least you must select one choice'}
)
elif survey_filed["type"] == "multiselect":
fields[survey_filed['variable']] = MultipleChoiceField(
label=survey_filed['question_name'],
initial=survey_filed['default'].split("\n"),
required=False if self.read_only_form else survey_filed['required'],
help_text=survey_filed['question_description'],
choices=get_choices_from_string(survey_filed["choices"]),
)
elif survey_filed["type"] == "integer":
fields[survey_filed['variable']] = IntegerField(
label=survey_filed['question_name'],
initial=0 if not survey_filed['default'] else int(survey_filed['default']),
required=False if self.read_only_form else survey_filed['required'],
help_text=survey_filed['question_description'],
min_value=survey_filed['min'],
max_value=survey_filed['max'],
)
elif survey_filed["type"] == "float":
fields[survey_filed['variable']] = FloatField(
label=survey_filed['question_name'],
initial=0 if not survey_filed['default'] else float(survey_filed['default']),
required=False if self.read_only_form else survey_filed['required'],
help_text=survey_filed['question_description'],
min_value=survey_filed['min'],
max_value=survey_filed['max'],
)
if self.read_only_form:
fields[survey_filed['variable']].default = survey_filed['default']
return fields
class BookRoomSerializer(Serializer):
room_type = ChoiceField(choices=ROOM_CHOICES, required=True)
date = DateField(required=True)
rooms_required = IntegerField(min_value=0, required=True)
class SuggestedCompanySerializer(ModelSerializer):
type = ChoiceField(choices=company_type.TYPE_CHOICES)
class Meta:
model = SuggestedCompany
exclude = ('id', )
class ShipmentSerializer(ShipmentData):
status = ChoiceField(required=False, choices=SHIPMENT_STATUS)
selected_rate_id = CharField(required=False)
rates = Rate(many=True, required=False)
label = CharField(required=False, allow_blank=True, allow_null=True)
tracking_number = CharField(required=False,
allow_blank=True,
allow_null=True)
shipment_identifier = CharField(required=False,
allow_blank=True,
allow_null=True)
selected_rate = Rate(required=False, allow_null=True)
tracking_url = CharField(required=False, allow_blank=True, allow_null=True)
test_mode = BooleanField(required=False)
def __init__(self, instance: models.Shipment = None, **kwargs):
if kwargs.get('data') is not None:
if isinstance(kwargs['data'], str):
payload = ShipmentData(
models.Shipment.objects.get(pk=kwargs['data'])).data
else:
payload = kwargs['data'].copy()
if payload.get('shipper') is not None:
payload.update(
shipper=SerializerDecorator[AddressSerializer]
((instance.shipper if instance is not None else None),
data=payload['shipper']).data)
if payload.get('recipient') is not None:
payload.update(
recipient=SerializerDecorator[AddressSerializer]
((instance.recipient if instance is not None else None
),
data=payload['recipient']).data)
if payload.get('parcels') is not None:
payload.update(parcels=[
SerializerDecorator[ParcelSerializer](data=parcel).data
for parcel in payload.get('parcels', [])
])
if payload.get('customs') is not None:
payload.update(
customs=SerializerDecorator[CustomsSerializer]
((instance.customs if instance is not None else None),
data=payload['customs']).data)
if payload.get('payment') is not None:
payload.update(
payment=SerializerDecorator[PaymentSerializer]
((instance.payment if instance is not None else None),
data=payload['payment']).data)
kwargs.update(data=payload)
super().__init__(instance, **kwargs)
@transaction.atomic
def create(self, validated_data: dict) -> models.Shipment:
user = validated_data['user']
carriers = Carrier.objects.filter(
carrier_id__in=validated_data.get('carrier_ids', []))
rate_response: datatypes.RateResponse = SerializerDecorator[
RateSerializer](data=validated_data).save(user=user).instance
test_mode = all([r.test_mode for r in rate_response.rates])
shipment_data = {
key: value
for key, value in validated_data.items()
if key in models.Shipment.DIRECT_PROPS and value is not None
}
related_data = dict(
shipper=SerializerDecorator[AddressSerializer](
data=validated_data.get('shipper')).save(user=user).instance,
recipient=SerializerDecorator[AddressSerializer](
data=validated_data.get('recipient')).save(user=user).instance,
customs=SerializerDecorator[CustomsSerializer](
data=validated_data.get('customs')).save(user=user).instance,
payment=SerializerDecorator[PaymentSerializer](
data=validated_data.get('payment')).save(user=user).instance,
)
shipment = models.Shipment.objects.create(
**{
**shipment_data,
**{k: v
for k, v in related_data.items() if v is not None}, 'user':
user,
'test_mode': test_mode,
'shipment_rates': DP.to_dict(rate_response.rates),
'messages': DP.to_dict(rate_response.messages)
})
shipment.carriers.set(carriers)
if validated_data.get('parcels') is not None:
shipment_parcels = [
SerializerDecorator[ParcelSerializer](data=data).save(
user=user).instance
for data in validated_data.get('parcels', [])
]
shipment.shipment_parcels.set(shipment_parcels)
return shipment
@transaction.atomic
def update(self, instance: models.Shipment,
validated_data: dict) -> models.Shipment:
data = validated_data.copy()
carrier_ids = validated_data.get('carrier_ids', [])
for key, val in data.items():
if key in models.Shipment.DIRECT_PROPS:
setattr(instance, key, val)
validated_data.pop(key)
if key in models.Shipment.RELATIONAL_PROPS and val is None:
prop = getattr(instance, key)
# Delete related data from database if payload set to null
if hasattr(prop, 'delete'):
prop.delete()
setattr(instance, key, None)
validated_data.pop(key)
if validated_data.get('payment') is not None:
instance.payment = SerializerDecorator[PaymentSerializer](
instance.payment, data=validated_data['payment']).save(
user=instance.user).instance
if validated_data.get('customs') is not None:
instance.customs = SerializerDecorator[CustomsSerializer](
data=validated_data.get('customs')).save(
user=instance.user).instance
if validated_data.get('rates') is not None:
instance.shipment_rates = DP.to_dict(
validated_data.get('rates', []))
if 'selected_rate' in validated_data:
selected_rate = validated_data.get('selected_rate', {})
carrier = Carrier.objects.filter(
carrier_id=selected_rate.get('carrier_id'),
user=instance.user).first()
instance.selected_rate = {
**selected_rate,
**({
'carrier_ref': carrier.id
} if carrier is not None else {})
}
instance.selected_rate_carrier = carrier
instance.save()
instance.carriers.set(
Carrier.objects.filter(carrier_id__in=carrier_ids,
user=instance.user))
return instance
class MediaSerializer(Serializer):
type = ChoiceField(choices=MEDIA_CHOICES)
