class CompanySerializerV1(dse_serializers.CassandraModelSerializer,
BaseCachedSerializerMixin):
"""
Represents a Business Object API View with support for JSON, list, and map
fields.
"""
user = serializers.HiddenField(default=dse_fields.CurrentUserNameDefault())
created_at = serializers.DateTimeField(
default=serializers.CreateOnlyDefault(datetime.utcnow))
address = AddressSerializerV1()
founders = fields.ListField(required=False, child=fields.UUIDField())
specialties = fields.ListField(required=False, child=fields.CharField())
latest_twitter_followers = fields.ListField(required=False,
child=fields.IntegerField())
websites = fields.DictField(required=False, child=fields.CharField())
crawler_config = dse_fields.CassandraJSONFieldAsText(required=False)
extra_data = dse_fields.CassandraJSONFieldAsText(required=False)
class Meta:
error_status_codes = {HTTP_400_BAD_REQUEST: "Bad Request"}
model = Company
fields = (
"_id",
"user",
"created_at",
"updated_at",
"name",
"short_description",
"foundation_date",
"country_code",
"stock_symbol",
"domain",
"last_round",
"round_notes",
"address",
"latitude",
"longitude",
"contact_email",
"founders",
"specialties",
"latest_twitter_followers",
"websites",
"crawler_config",
"extra_data",
"point",
"linestring",
)
read_only_fields = ("_id", "user", "created_at", "updated_at")
class YupanaHostSerializer(NotEmptyMixin, Serializer):
"""Serializer to format hosts to yupana/hbi."""
display_name = fields.CharField(source="name", **default_kwargs)
bios_uuid = fields.CharField(**default_kwargs)
fqdn = fields.CharField(
source="name", **default_kwargs
) # TODO: not sure on this one, just followed old implementation https://github.com/quipucords/quipucords/blob/da644172fb35ad7128ba20372cf64fbf7ff4f367/quipucords/fingerprinter/task.py#L373 # noqa: E501
insights_id = fields.CharField(source="insights_client_id", **default_kwargs)
ip_addresses = fields.ListField(child=fields.CharField(), **default_kwargs)
mac_addresses = fields.ListField(child=fields.CharField(), **default_kwargs)
provider_id = fields.CharField(
source="name", **default_kwargs
) # TODO: not sure on this one
provider_type = fields.CharField(**default_kwargs)
satellite_id = fields.CharField(
**default_kwargs
) # TODO: not sure on this one https://github.com/RedHatInsights/insights-host-inventory/blob/813a290f3a1c702312d8e02d1e59ba328c6f8143/swagger/api.spec.yaml#L901-L907 # noqa: E501
subscription_manager_id = fields.CharField(**default_kwargs)
facts = FactsetSerializer(source="*", many=True)
system_profile = SystemProfileSerializer(source="*", **default_kwargs)
def to_representation(self, instance):
"""Format HostEntity as dict and validate."""
data = super().to_representation(instance)
self.validate(data)
return data
def validate(self, attrs: dict):
"""Validate serializer data."""
attrs = self._validate_canonical_facts(attrs)
attrs = self._validate_provider(attrs)
return attrs
def _validate_provider(self, attrs: dict):
# hbi requires either provider_id and provider_type or none
# https://github.com/RedHatInsights/insights-host-inventory/blob/813a290f3a1c702312d8e02d1e59ba328c6f8143/swagger/api.spec.yaml#L943-L957 # noqa: E501
provider_attrs = {"provider_id", "provider_type"}
present_provider_attr_set = provider_attrs & set(attrs)
if len(present_provider_attr_set) != 1:
return attrs
present_provider_attr = present_provider_attr_set.pop()
attrs.pop(present_provider_attr)
return attrs
def _validate_canonical_facts(self, attrs):
if not set(attrs).intersection(CANONICAL_FACTS):
raise ValidationError(
"At least one 'canonical fact' must be present on the report. "
f"(Canonical facts are: {CANONICAL_FACTS})"
)
return attrs
class BaseResultSerializer(Serializer):
id = fields.CharField()
type = fields.CharField()
source = fields.CharField()
title = fields.CharField()
#abstract = fields.CharField()
#summary = fields.CharField()
language = fields.CharField(required=False)
country = fields.CharField(required=False)
date = fields.DateField()
subjects = fields.ListField()
keywords = fields.ListField()
class PresentacionSerializer(serializers.EmbeddedDocumentSerializer):
nombre = fields.CharField(required=True)
precio_compra = fields.FloatField(required=True)
precio_venta = fields.FloatField(required=True)
lotes = fields.ListField(LotesSerializer(required=True))
medidas = MedidasSerializar(required=False)
detalle_unitario = fields.ListField(
DetalleUnitarioSerializer(required=False))
class Meta:
model = Presentacion
fields = "__all__"
class ExperimentSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = Experiment
# fixme: how to embed the through relation?
# users = UserExperimentSerializer(many=True, read_only=True)
files = fields.ListField(child=URLPathField(), source="file_urls")
class FactsSerializer(Serializer):
"""Serializer for HBI facts."""
source_types = fields.ListField()
last_discovered = fields.DateTimeField()
qpc_server_version = fields.CharField(default=server_version)
qpc_server_id = fields.CharField(default=get_server_id)
class ReclaimSpaceSerializer(serializers.Serializer, ValidateFieldsMixin):
"""
Serializer for reclaim disk space operation.
"""
repo_hrefs = fields.ListField(
required=True,
help_text=_("Will reclaim space for the specified list of repos."),
)
repo_versions_keeplist = RepositoryVersionRelatedField(
help_text=_("Will exclude repo versions from space reclaim."),
many=True,
required=False,
)
def validate_repo_hrefs(self, value):
"""
Check that the repo_hrefs is not an empty list and contains all valid hrefs.
Args:
value (list): The list supplied by the user
Returns:
The list of pks (not hrefs) after validation
Raises:
ValidationError: If the list is empty or contains invalid hrefs.
"""
if len(value) == 0:
raise serializers.ValidationError("Must not be [].")
from pulpcore.app.viewsets import NamedModelViewSet
hrefs_to_return = []
for href in value:
hrefs_to_return.append(
NamedModelViewSet.get_resource(href, Repository))
return hrefs_to_return
class OrphansCleanupSerializer(serializers.Serializer, ValidateFieldsMixin):
content_hrefs = fields.ListField(
required=False,
help_text=_("Will delete specified content and associated Artifacts if they are orphans."),
)
def validate_content_hrefs(self, value):
"""
Check that the content_hrefs is not an empty list and contains all valid hrefs.
Args:
value (list): The list supplied by the user
Returns:
The list of pks (not hrefs) after validation
Raises:
ValidationError: If the list is empty or contains invalid hrefs.
"""
if len(value) == 0:
raise serializers.ValidationError("Must not be [].")
from pulpcore.app.viewsets import NamedModelViewSet
pks_to_return = []
for href in value:
pks_to_return.append(NamedModelViewSet.get_resource(href, Content).pk)
return pks_to_return
class ConfigurationSerializer(serializers.Serializer):
priority = fields.ChoiceField(PRIORITY)
scheduler = fields.ChoiceField(SCHEDULER_TYPE)
max_tasks = fields.IntegerField(min_value=1)
weight = fields.ChoiceField(DECISION_WEIGHT)
parallelism = fields.ListField(child=fields.RegexField(r'^\d+(\.\d+)?$'),
min_length=4,
max_length=4)
memory = fields.FloatField()
cpu_num = fields.IntegerField(allow_null=True, min_value=1)
disk_size = fields.FloatField()
cpu_model = fields.CharField(default='', allow_null=True, allow_blank=True)
cpu_time_exec_cmds = fields.FloatField()
memory_exec_cmds = fields.FloatField()
console_level = fields.ChoiceField(LOGGING_LEVELS)
file_level = fields.ChoiceField(LOGGING_LEVELS)
console_formatter = fields.CharField()
file_formatter = fields.CharField()
keep_intermediate_files = fields.BooleanField()
upload_verifier_files = fields.BooleanField()
upload_other_files = fields.BooleanField()
ignore_subjobs = fields.BooleanField()
total_coverage = fields.BooleanField()
coverage_details = fields.ChoiceField(COVERAGE_DETAILS)
def create(self, validated_data):
raise NotImplementedError
def update(self, instance, validated_data):
raise NotImplementedError
class MeasurementsSerializer(serializers.Serializer):
timestamp = serializers.DateTimeField(required=True)
#timestamp = fields.DateTimeField(input_formats=[%Y-%m-%dT%H:%M:%S.%fZ], required=True)
metrics = fields.ListField(
child=fields.DictField(child=fields.FloatField()),
help_text=
'Any matric field like temperature, dew point, precipitation or can be added new one in the future',
)
class ContactFormSeralizer(serializers.Serializer):
name = fields.CharField()
message = fields.CharField()
email = fields.CharField()
phone = fields.CharField(required=False)
recipients = fields.ListField()
class Meta:
fields = ['name', 'message', 'email', 'phone']
class PresetsArgsSerializer(Serializer):
class Meta:
list_serializer_class = PresetArgsListSerializer
slug = fields.SlugField()
label = fields.CharField()
help_text = fields.CharField(required=False)
placehorlder = fields.CharField(required=False)
types = fields.ListField()
class TicketSerializer(serializers.ModelSerializer):
log = fields.ListField(child=fields.JSONField())
info = fields.SerializerMethodField(read_only=True)
class Meta:
model = Ticket
fields = ('store', 'created_at', 'updated_at', 'created_by',
'updated_by', 'is_invoiced', 'log', 'info')
def get_info(self, obj):
return {}
class CompanySearchSerializerV1(CustomHaystackSerializer,
BaseCachedSerializerMixin):
"""
A Fast Searcher (Solr) version of the original Business Object API View
"""
address = AddressSerializerV1()
founders = fields.ListField(required=False, child=fields.UUIDField())
specialties = fields.ListField(required=False, child=fields.CharField())
latest_twitter_followers = fields.ListField(
required=False, child=fields.IntegerField())
websites = fields.DictField(required=False, child=fields.CharField())
crawler_config = dse_fields.CassandraJSONFieldAsText(required=False)
extra_data = dse_fields.CassandraJSONFieldAsText(required=False)
score = fields.FloatField(required=False)
class Meta(CustomHaystackSerializer.Meta):
model = Company
# The `index_classes` attribute is a list of which search indexes
# we want to include in the search.
index_classes = [CompanyIndex]
# The `fields` contains all the fields we want to include.
# NOTE: Make sure you don't confuse these with model attributes. These
# fields belong to the search index!
fields = [
"_id", "created_at", "updated_at",
"name", "short_description", "foundation_date",
"last_round", "round_notes",
"country_code", "stock_symbol", "domain",
"address", "latitude", "longitude",
"contact_email", "founders", "specialties",
"latest_twitter_followers", "websites", "crawler_config",
"extra_data",
"text", "score"
]
class SafeMarkVersionSerializer(WithTagsMixin, serializers.ModelSerializer):
tags = fields.ListField(child=fields.CharField(),
allow_empty=True,
write_only=True)
attrs = fields.ListField(child=SafeMarkAttrSerializer(),
allow_empty=True,
write_only=True)
def validate_tags(self, tags):
return self.get_tags_ids(tags)
def get_value(self, dictionary):
return dictionary
def create(self, validated_data):
if 'mark' not in validated_data:
raise exceptions.ValidationError(detail={'mark': 'Required'})
return create_mark_version(validated_data.pop('mark'),
**validated_data)
def update(self, instance, validated_data):
raise RuntimeError('Update of mark version object is not allowed')
def to_representation(self, instance):
value = super().to_representation(instance)
if isinstance(instance, MarkSafeHistory):
value['attrs'] = SafeMarkAttrSerializer(
instance=instance.attrs.order_by('id'), many=True).data
value['tags'] = list(
instance.tags.values_list('tag__name', flat=True))
return value
class Meta:
model = MarkSafeHistory
fields = ('change_date', 'comment', 'description', 'verdict', 'tags',
'attrs')
class UnknownMarkVersionSerializer(serializers.ModelSerializer):
attrs = fields.ListField(child=UnsafeMarkAttrSerializer(),
allow_empty=True,
write_only=True)
def validate(self, attrs):
res = super().validate(attrs)
if res.get('is_regexp'):
try:
re.search(res['function'], '')
except Exception as e:
logger.exception(e)
raise exceptions.ValidationError(
detail={
'function':
_("The pattern is wrong, please refer to documentation on the standard "
"Python library for processing reqular expressions")
})
return res
def get_value(self, dictionary):
return dictionary
def create(self, validated_data):
if 'mark' not in validated_data:
raise exceptions.ValidationError(detail={'mark': 'Required'})
return create_mark_version(validated_data.pop('mark'),
**validated_data)
def update(self, instance, validated_data):
raise RuntimeError('Update of mark version object is not allowed')
def to_representation(self, instance):
res = super().to_representation(instance)
if isinstance(instance, MarkUnknownHistory):
res['attrs'] = UnknownMarkAttrSerializer(
instance=instance.attrs.order_by('id'), many=True).data
return res
class Meta:
model = MarkUnknownHistory
fields = ('change_date', 'comment', 'description', 'attrs', 'function',
'is_regexp', 'problem_pattern', 'link')
class OrphansCleanupSerializer(serializers.Serializer, ValidateFieldsMixin):
content_hrefs = fields.ListField(
required=False,
help_text=
_("Will delete specified content and associated Artifacts if they are orphans."
),
)
orphan_protection_time = serializers.IntegerField(
help_text=
("The time in minutes for how long Pulp will hold orphan Content and Artifacts before "
"they become candidates for deletion by this orphan cleanup task. This should ideally "
"be longer than your longest running task otherwise any content created during that "
"task could be cleaned up before the task finishes. If not specified, default is used "
"from settings which is 1440 minutes (24 hours)"),
allow_null=True,
required=False,
default=settings.ORPHAN_PROTECTION_TIME,
)
def validate_content_hrefs(self, value):
"""
Check that the content_hrefs is not an empty list and contains all valid hrefs.
Args:
value (list): The list supplied by the user
Returns:
The list of pks (not hrefs) after validation
Raises:
ValidationError: If the list is empty or contains invalid hrefs.
"""
if len(value) == 0:
raise serializers.ValidationError("Must not be [].")
from pulpcore.app.viewsets import NamedModelViewSet
pks_to_return = []
for href in value:
pks_to_return.append(
NamedModelViewSet.get_resource(href, Content).pk)
return pks_to_return
class Meta:
_view_class = ModelViewSet
_list_fields = [
'name',
]
_detail_fields = _list_fields + [
'variables_list',
'variables_ser',
]
_override_detail_fields = {
'variables_list':
drf_fields.ListField(read_only=True,
child=drf_fields.DictField(read_only=True)),
'variables_ser':
SubVariablesSerializer(many=True, read_only=True)
}
_nested = {
'vars': {
'manager_name': 'variables',
'allow_append': False,
'model': 'test_proj.models.contented.Variable',
}
}
class TestSerializer(serializers.Serializer):
my_num = fields.IntegerField(required=True)
my_str = fields.CharField(required=True)
strs = fields.ListField(child=fields.CharField())
class UnsafeMarkVersionSerializer(WithTagsMixin, serializers.ModelSerializer):
tags = fields.ListField(child=fields.CharField(),
allow_empty=True,
write_only=True)
attrs = fields.ListField(child=UnsafeMarkAttrSerializer(),
allow_empty=True,
write_only=True)
error_trace = fields.CharField(write_only=True, required=False)
threshold = fields.IntegerField(min_value=0,
max_value=100,
write_only=True,
default=0)
def validate_tags(self, tags):
return self.get_tags_ids(tags)
def validate_threshold(self, value):
return value / 100
def __validate_error_trace(self, err_trace_str, compare_func):
convert_func = COMPARE_FUNCTIONS[compare_func]['convert']
assert convert_func in CONVERT_FUNCTIONS
forests = json.loads(err_trace_str)
return save_converted_trace(forests, convert_func)
def validate(self, attrs):
res = super().validate(attrs)
if 'error_trace' in res:
try:
res['error_trace'] = self.__validate_error_trace(
res.pop('error_trace'), res['function'])
except Exception as e:
logger.exception(e)
raise exceptions.ValidationError(
detail={'error_trace': _('Wrong error trace is provided')})
if res['verdict'] != UNSAFE_VERDICTS[1][0]:
res['status'] = None
elif not res.get('status'):
raise exceptions.ValidationError(
detail={'status': _('Wrong status value')})
return res
def get_value(self, dictionary):
return dictionary
def create(self, validated_data):
if 'mark' not in validated_data:
raise exceptions.ValidationError(detail={'mark': 'Required'})
if 'error_trace' not in validated_data:
raise exceptions.ValidationError(
detail={'error_trace': 'Required'})
return create_mark_version(validated_data.pop('mark'),
**validated_data)
def update(self, instance, validated_data):
raise RuntimeError('Update of mark version object is not allowed')
def to_representation(self, instance):
res = super().to_representation(instance)
if isinstance(instance, MarkUnsafeHistory):
conv = ConvertedTrace.objects.get(id=instance.error_trace_id)
with conv.file.file as fp:
res['error_trace'] = json.loads(fp.read().decode('utf-8'))
res['attrs'] = UnsafeMarkAttrSerializer(
instance=instance.attrs.order_by('id'), many=True).data
res['tags'] = list(
instance.tags.values_list('tag__name', flat=True))
res['threshold'] = instance.threshold_percentage
return res
class Meta:
model = MarkUnsafeHistory
fields = ('change_date', 'comment', 'description', 'verdict', 'status',
'tags', 'attrs', 'function', 'error_trace', 'threshold')
class RunSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = Run
files = fields.ListField(child=URLPathField(), source="file_urls")
class MonthMetricsSerializer(serializers.Serializer):
dates = fields.ListField(
child=fields.CharField(min_length=3, max_length=5))
video_minutes_list = fields.ListField(child=fields.IntegerField(
min_value=0))
audio_minutes_list = fields.ListField(child=fields.IntegerField(
min_value=0))
total_minutes_list = fields.ListField(child=fields.IntegerField(
min_value=0))
video_plays_list = fields.ListField(child=fields.IntegerField(min_value=0))
audio_plays_list = fields.ListField(child=fields.IntegerField(min_value=0))
total_plays_list = fields.ListField(child=fields.IntegerField(min_value=0))
archive_video_minutes_list = fields.ListField(
child=fields.IntegerField(min_value=0), required=False)
archive_audio_minutes_list = fields.ListField(
child=fields.IntegerField(min_value=0), required=False)
archive_total_minutes_list = fields.ListField(
child=fields.IntegerField(min_value=0), required=False)
archive_video_plays_list = fields.ListField(
child=fields.IntegerField(min_value=0), required=False)
archive_audio_plays_list = fields.ListField(
child=fields.IntegerField(min_value=0), required=False)
archive_total_plays_list = fields.ListField(
child=fields.IntegerField(min_value=0), required=False)
class ExplicitSerializer(DocumentSerializer):
class Meta:
model = EmbeddingThing
fields = '__all__'
embedded = drf_fields.ListField(child=EmbeddedThingSerializer())
class ValuesSerializer(BaseSerializer):
count = fields.IntegerField(min_value=0)
results = fields.ListField(allow_empty=True)
class AttributesListSerializer(serializers.Serializer):
attributes = fields.ListField()
class WordCloudSerializer(serializers.Serializer):
cloud = fields.ListField()
class CompanyGEOSearchSerializerV1(CustomHaystackSerializer,
BaseCachedSerializerMixin):
"""
A Fast Searcher (Solr) version of the original Business Object API View
to do GEO Spatial searches
"""
address = AddressSerializerV1()
founders = fields.ListField(required=False, child=fields.UUIDField())
specialties = fields.ListField(required=False, child=fields.CharField())
latest_twitter_followers = fields.ListField(required=False,
child=fields.IntegerField())
websites = fields.DictField(required=False, child=fields.CharField())
crawler_config = dse_fields.CassandraJSONFieldAsText(required=False)
extra_data = dse_fields.CassandraJSONFieldAsText(required=False)
score = fields.FloatField(required=False)
distance = dse_fields.DistanceField(required=False, units="m")
class Meta(CustomHaystackSerializer.Meta):
model = Company
# The `index_classes` attribute is a list of which search indexes
# we want to include in the search.
index_classes = [CompanyIndex]
fields = [
"_id",
"created_at",
"updated_at",
"name",
"short_description",
"foundation_date",
"last_round",
"round_notes",
"country_code",
"stock_symbol",
"domain",
"address_street_type",
"address_street_name",
"address_street_number",
"address_state",
"address_region",
"address_city",
"address_country_code",
"address_zipcode",
"latitude",
"longitude",
"contact_email",
"founders",
"specialties",
"latest_twitter_followers",
"websites",
"crawler_config",
"extra_data",
"text",
"score",
"distance",
"point",
"linestring",
]
class TaskSerializerV1(dse_serializers.CassandraModelSerializer,
BaseCachedSerializerMixin):
"""
Represents a Business Object API View with support for JSON and map
fields.
"""
user = serializers.CharField(required=False)
params = dse_fields.CassandraJSONFieldAsText(
required=True,
help_text="the set of params used to execute the crawler"
" command, this will be saved as Text.")
options = dse_fields.CassandraJSONFieldAsText(
required=False,
help_text="the exactly same content as `options` but saved"
" on a way that we can search using solr "
"(KeyEncodedMap).",
)
more_info = fields.ListField(required=False,
allow_null=True,
child=TaskMoreInfoSerializer())
differences_from_last_version = fields.JSONField(required=False,
allow_null=True)
inserted_fields = fields.ListField(required=False,
allow_null=True,
child=serializers.CharField())
updated_fields = fields.ListField(required=False,
allow_null=True,
child=serializers.CharField())
deleted_fields = fields.ListField(required=False,
allow_null=True,
child=serializers.CharField())
changed_fields = fields.ListField(required=False,
allow_null=True,
child=serializers.CharField())
def create(self, validated_data):
request = self.context.get("request", None)
if request:
self.validated_data["user"] = str(request.user.id)
return super(TaskSerializerV1, self).create(validated_data)
class Meta:
model = Task
fields = (
"task_id",
"user",
"created_at",
"updated_at",
"is_deleted",
"status",
"kind",
"params",
"times_performed",
"type",
"options",
"more_info",
"differences_from_last_version",
"inserted_fields",
"updated_fields",
"deleted_fields",
"changed_fields",
"logging_task",
)
read_only_fields = (
"created_at",
"updated_at",
"is_deleted",
"status",
"times_performed",
"type",
"params_map",
"options_map",
"differences_from_last_version",
"inserted_fields",
"updated_fields",
"deleted_fields",
"changed_fields",
"logging_task",
)
extra_kwargs = {
"task_id": {
"help_text": "the task id that is the unique partition key."
},
"user": {
"help_text":
"The user that asked for the task, if it is an "
"ondemand task."
},
"created_at": {
"help_text": "the date of the creation of the task."
},
"updated_at": {
"help_text": "the date that we last updated the task."
},
"is_deleted": {
"help_text": "controls if the data is deleted."
},
"status": {
"help_text": """
represents the actual status of the task, could be:
- 0 (Created)
- 1 (Queued)
- 2 (In Progress)
- 3 (Finished)
- 4 (Faulty)
- 5 (Unknown)
""",
"default": STATUS_CREATED,
},
"kind": {
"help_text":
"the name of the crawler that will execute the "
"task."
},
"times_performed": {
"help_text": "keep track on how many times the task was run."
},
"type": {
"help_text": "the type of the task, could be OnDemand(1) or "
"Batch(2)",
"default": ON_DEMAND_TASK,
},
"more_info": {
"help_text":
"more info about the task, for example, something"
"about the maintenance state"
},
}
class MonthMetricsSerializer(serializers.Serializer):
dates = fields.ListField(child=fields.DateField())
total_minutes_list = fields.ListField(child=fields.IntegerField(
min_value=0))
total_plays_list = fields.ListField(child=fields.IntegerField(min_value=0))
class DivergingSerializer(serializers.Serializer):
_id = fields.CharField()
children = fields.ListField()
