class FilterPlaceSerializer(serializers.Serializer):
city_id = serializers.IntegerField()
filter = serializers.JSONField()
slug = serializers.CharField()
price = serializers.ListField(required=False,
child=serializers.IntegerField(min_value=1,
max_value=4))
def validate_city(self, city_id):
if not places_models.City.objects.filter(city_id=city_id).exists():
raise serializers.ValidationError(_('City does not exist.'))
return city_id
def validate_slug(self, slug):
if not places_models.PlaceType.objects.filter(slug=slug).exists():
raise serializers.ValidationError(_('Incorrect slug.'))
return slug
def validate_filter(self, filter):
updated_filter = []
for attr in filter:
field_type_id = attr.get('id', None)
field_type_data = attr.get('data', None)
field_type_options = attr.get('options', None)
if not field_type_id:
raise serializers.ValidationError(
_('Please, provide `id` for every filter\'s attribute.'))
if not field_type_data and not field_type_options:
raise serializers.ValidationError(
_('Please, provide `data` or `options` '
'for every filter\'s attribute.'))
try:
field_type_obj = filter_models.FilterField.objects.get(
id=field_type_id)
if isinstance(field_type_obj, filter_models.ChoiceFilterField) \
and field_type_obj.is_multi:
if field_type_data and not isinstance(
field_type_data, list):
raise serializers.ValidationError(
_('data for filter with id={} should be list, not {}.'
.format(field_type_id, type(field_type_data))))
if field_type_options and not isinstance(
field_type_options, list):
raise serializers.ValidationError(
_('options for filter with id={} should be list, not {}.'
.format(field_type_id,
type(field_type_options))))
if isinstance(field_type_obj, filter_models.ChoiceFilterField):
attr[
'field_type'] = 'multi' if field_type_obj.is_multi else 'choice'
elif isinstance(field_type_obj, filter_models.BoolFilterField):
attr['field_type'] = 'bool'
elif isinstance(field_type_obj, filter_models.TextFilterField):
attr['field_type'] = 'text'
else:
raise serializers.ValidationError(
_('Unexpected type ob object {}'.format(
field_type_obj)))
updated_filter.append(attr)
except filter_models.FilterField.DoesNotExist:
raise serializers.ValidationError(
_('FieldType object with provided id={} does not exist.'.
format(field_type_id)))
return updated_filter
class HealthStatsSerializer(serializers.ModelSerializer):
diseases_details = serializers.JSONField()
class Meta:
model = HealthStatsSerializerModel
fields = ('total', 'ageGroup', 'gender', 'diseases_details')
class TimeseriesHealthStatsSerializer(serializers.ModelSerializer):
values = serializers.JSONField()
class Meta:
model = TimeseriesHealthStatsModel
fields = ('date', 'values')
class JobTypeDetailsSerializerV6(JobTypeSerializerV6):
"""Converts job type model fields to REST output."""
manifest = serializers.JSONField(default=dict)
configuration = serializers.JSONField(source='get_v6_configuration_json')
class JobTypeRevisionDetailsSerializerV6(JobTypeRevisionSerializerV6):
"""Converts job type revision model fields to REST output."""
job_type = JobTypeBaseSerializerV6()
manifest = serializers.JSONField(default=dict)
class ClientCreateSerializer(serializers.ModelSerializer):
"""
For Create POST requests only
"""
qs = RiskProfileAnswer.objects.all()
risk_profile_responses = serializers.PrimaryKeyRelatedField(many=True,
queryset=qs,
required=False)
residential_address = AddressUpdateSerializer(required=False)
regional_data = serializers.JSONField()
ib_onboard = IBOnboardCreateSerializer(required=False)
class Meta:
model = Client
fields = (
'employment_status',
RESIDENTIAL_ADDRESS_KEY,
'income',
'other_income',
'occupation',
'industry_sector',
'employer_type',
'student_loan',
'student_loan_assistance_program',
'student_loan_graduate_looking',
'student_loan_parent_looking',
'hsa_eligible',
'hsa_provider_name',
'hsa_state',
'hsa_coverage_type',
'employer',
'civil_status',
'risk_profile_responses',
'betasmartz_agreement',
'advisor_agreement',
'politically_exposed',
'phone_num',
'regional_data',
'smoker',
'daily_exercise',
'weight',
'height',
'drinks',
'date_of_birth',
'gender',
'ib_onboard',
)
def validate_phone_num(self, phone_num):
serializer = PhoneNumberValidationSerializer(
data={'number': phone_num})
if not serializer.is_valid():
raise serializers.ValidationError('Invalid phone number')
return serializer.validated_data['number']
@transaction.atomic
def create(self, validated_data):
# Default to Personal account type for risk profile group on a brand
# new client (since they have no accounts yet, we have to assume)
rpg = RiskProfileGroup.objects.get(
account_types__account_type=constants.ACCOUNT_TYPE_PERSONAL)
validated_data['risk_profile_group'] = rpg
if RESIDENTIAL_ADDRESS_KEY in validated_data:
address_ser = AddressUpdateSerializer(
data=validated_data.pop(RESIDENTIAL_ADDRESS_KEY))
else:
address_ser = AddressUpdateSerializer(data=UNSET_ADDRESS)
address_ser.is_valid(raise_exception=True)
validated_data[RESIDENTIAL_ADDRESS_KEY] = address_ser.save()
if 'ib_onboard' in validated_data:
ib_onboard_ser = IBOnboardCreateSerializer(
data=validated_data.pop('ib_onboard'))
ib_onboard_ser.is_valid(raise_exception=True)
# For now we auto confirm and approve the client.
validated_data['is_confirmed'] = True
validated_data['is_accepted'] = True
client = super(ClientCreateSerializer, self).create(validated_data)
client_account = client.primary_accounts.create(
account_type=constants.ACCOUNT_TYPE_PERSONAL,
default_portfolio_set=validated_data['advisor'].
default_portfolio_set,
confirmed=True,
)
if 'ib_onboard_ser' in locals():
ib_onboard = ib_onboard_ser.save(client=client)
if ib_onboard.account_number is not None: # If the client already has IB account create and link IBAccount object
ib_account = IBAccount(bs_account=client_account,
ib_account=ib_onboard.account_number)
ib_account.save()
else:
# connect IB broker onboarding ftp
status = onboarding.onboard('INDIVIDUAL', ib_onboard)
return client
class PrivateInvitationSerializer(serializers.ModelSerializer):
"""
Authenticated users will retrieve and update through this
serializer.
"""
# Includes onboarding data
# Allows POST for registered users
onboarding_data = serializers.JSONField()
risk_profile_group = serializers.SerializerMethodField()
firm_name = serializers.SerializerMethodField()
firm_logo = serializers.SerializerMethodField()
client_agreement_url = serializers.SerializerMethodField()
firm_colored_logo = serializers.SerializerMethodField()
tax_transcript_data = serializers.SerializerMethodField()
social_security_statement_data = serializers.SerializerMethodField()
partner_social_security_statement_data = serializers.SerializerMethodField(
)
firm_config = serializers.SerializerMethodField()
class Meta:
model = EmailInvite
read_only_fields = (
'invite_key',
'email',
'status',
'client_agreement_url',
'salutation',
'invitation',
'firm_config',
)
fields = (
'email',
'invite_key',
'status',
'onboarding_data',
'risk_profile_group',
'reason',
'advisor',
'firm_name',
'firm_logo',
'firm_config',
'client_agreement_url',
'firm_colored_logo',
'tax_transcript',
'tax_transcript_data', # this will be stored to client.region_data.tax_transcript_data
'social_security_statement',
'social_security_statement_data',
'partner_social_security_statement',
'partner_social_security_statement_data',
'salutation',
'suffix',
'photo_verification',
'risk_score',
'ib_account_number')
def get_risk_profile_group(self, obj):
return AccountTypeRiskProfileGroup.objects.get(
account_type=ACCOUNT_TYPE_PERSONAL).id
def get_firm_name(self, obj):
return obj.advisor.firm.name
def get_firm_logo(self, obj):
return obj.advisor.firm.white_logo
def get_firm_colored_logo(self, obj):
return obj.advisor.firm.colored_logo
def get_firm_config(self, obj):
serializer = FirmConfigSerializer(obj.advisor.firm.config)
return serializer.data
def get_client_agreement_url(self, obj):
cau = obj.advisor.firm.client_agreement_url
return settings.SITE_URL + cau.url if cau else None
def get_tax_transcript_data(self, obj):
# parse_pdf
if obj.tax_transcript:
# save to tmp file to pass to parse_pdf
# TODO: parse_pdf using subprocess file status command
# to detect pdf_fonts, need to replace that with
# something we can pass the in-memory file data here
tmp_filename = '/tmp/' + str(uuid.uuid4()) + '.pdf'
with open(tmp_filename, 'wb+') as f:
for chunk in obj.tax_transcript.chunks():
f.write(chunk)
obj.tax_transcript_data = parse_tax_pdf(tmp_filename)
return obj.tax_transcript_data
return None
def get_social_security_statement_data(self, obj):
if obj.social_security_statement:
tmp_filename = '/tmp/' + str(uuid.uuid4()) + '.pdf'
with open(tmp_filename, 'wb+') as f:
for chunk in obj.social_security_statement.chunks():
f.write(chunk)
obj.social_security_statement_data = parse_ss_pdf(tmp_filename)
return obj.social_security_statement_data
return None
def get_partner_social_security_statement_data(self, obj):
if obj.partner_social_security_statement:
tmp_filename = '/tmp/' + str(uuid.uuid4()) + '.pdf'
with open(tmp_filename, 'wb+') as f:
for chunk in obj.partner_social_security_statement.chunks():
f.write(chunk)
obj.partner_social_security_statement_data = parse_ss_pdf(
tmp_filename)
return obj.partner_social_security_statement_data
return None
class NotificationSerializer(serializers.ModelSerializer):
source_uid = serializers.ReadOnlyField(source='source_id', read_only=True)
source_name = serializers.SerializerMethodField(read_only=True)
source_img = serializers.ReadOnlyField(
source='source.user_profile.profile_picture.url', read_only=True)
get_source_url = serializers.ReadOnlyField()
get_event_name = serializers.ReadOnlyField()
get_event_url = serializers.SerializerMethodField()
get_extraobj_name = serializers.ReadOnlyField()
get_extraobj_url = serializers.ReadOnlyField()
get_absolute_url = serializers.ReadOnlyField()
extra_json = serializers.JSONField(binary=False)
terms_and_labels = serializers.SerializerMethodField()
# org_name = serializers.ReadOnlyField(source='organization.name', read_only=True)
# get_org_url = serializers.ReadOnlyField()
# project_name = serializers.ReadOnlyField(source='project.name', read_only=True)
# get_project_url = serializers.ReadOnlyField()
# site_name = serializers.ReadOnlyField(source='site.name', read_only=True)
# get_site_url = serializers.ReadOnlyField()
class Meta:
model = FieldSightLog
exclude = (
'description',
'project',
'is_seen',
'content_type',
'organization',
'site',
'object_id',
'extra_object_id',
'source',
'extra_content_type',
)
def get_source_name(self, obj):
return obj.source.first_name + " " + obj.source.last_name
def get_get_event_url(self, obj):
if obj.type in [16, 17, 18, 19, 31, 33
] and obj.content_object.is_deleted if isinstance(
obj.content_object, FieldSightXF) else False:
get_event_url = '#'
else:
get_event_url = obj.get_event_url()
return get_event_url
def get_terms_and_labels(self, obj):
if obj.project:
terms = ProjectLevelTermsAndLabels.objects.select_related(
'project').filter(project=obj.project)
if terms:
return {
'site':
obj.project.terms_and_labels.site,
'sub_site':
obj.project.terms_and_labels.sub_site,
'donor':
obj.project.terms_and_labels.donor,
'site_supervisor':
obj.project.terms_and_labels.site_supervisor,
'site_reviewer':
obj.project.terms_and_labels.site_reviewer,
'region':
obj.project.terms_and_labels.region,
'region_supervisor':
obj.project.terms_and_labels.region_supervisor,
'region_reviewer':
obj.project.terms_and_labels.region_reviewer,
}
class RetirementPlanSerializer(ReadOnlyModelSerializer):
# We need to force JSON output for the JSON fields....
expenses = serializers.JSONField()
savings = serializers.JSONField()
initial_deposits = serializers.JSONField()
retirement_accounts = serializers.JSONField()
partner_data = serializers.JSONField()
portfolio = PortfolioSerializer()
on_track = serializers.BooleanField()
statement_of_advice = serializers.PrimaryKeyRelatedField(read_only=True)
statement_of_advice_url = serializers.SerializerMethodField(required=False)
civil_status = serializers.SerializerMethodField(required=False)
smoker = serializers.SerializerMethodField(required=False)
daily_exercise = serializers.SerializerMethodField(required=False)
weight = serializers.SerializerMethodField(required=False)
height = serializers.SerializerMethodField(required=False)
drinks = serializers.SerializerMethodField(required=False)
balance = serializers.FloatField()
home_value = serializers.SerializerMethodField(required=False)
home_growth = serializers.SerializerMethodField(required=False)
ss_fra_todays = serializers.SerializerMethodField(required=False)
ss_fra_retirement = serializers.SerializerMethodField(required=False)
state_tax_after_credits = serializers.SerializerMethodField(required=False)
state_tax_effrate = serializers.SerializerMethodField(required=False)
pension_name = serializers.SerializerMethodField(required=False)
pension_amount = serializers.SerializerMethodField(required=False)
pension_start_date = serializers.SerializerMethodField(required=False)
employee_contributions_last_year = serializers.SerializerMethodField(required=False)
employer_contributions_last_year = serializers.SerializerMethodField(required=False)
total_contributions_last_year = serializers.SerializerMethodField(required=False)
tax_transcript = serializers.FileField(source='client.user.invitation.tax_transcript', required=False)
tax_transcript_data = serializers.SerializerMethodField(required=False)
social_security_statement = serializers.SerializerMethodField(source='client.user.invitation.social_security_statement', required=False)
social_security_statement_data = serializers.SerializerMethodField(required=False)
partner_social_security_statement = serializers.SerializerMethodField(source='client.user.invitation.partner_social_security_statement', required=False)
partner_social_security_statement_data = serializers.SerializerMethodField(required=False)
date_of_estimate = serializers.DateField(required=False)
class Meta:
model = RetirementPlan
# Goal setting is an internal field that doesn't need to be shared externally.
exclude = ('goal_setting',)
def get_statement_of_advice_url(self, obj):
if hasattr(obj, 'statement_of_advice'):
return '/statements/retirement/{}.pdf'.format(obj.statement_of_advice.id)
else:
return None
def get_civil_status(self, obj):
return obj.client.civil_status
def get_smoker(self, obj):
return obj.client.smoker
def get_daily_exercise(self, obj):
return obj.client.daily_exercise
def get_weight(self, obj):
return obj.client.weight
def get_height(self, obj):
return obj.client.height
def get_drinks(self, obj):
return obj.client.drinks
def get_home_value(self, obj):
return obj.client.home_value
def get_home_growth(self, obj):
return obj.client.home_growth
def get_ss_fra_todays(self, obj):
return obj.client.ss_fra_todays
def get_ss_fra_retirement(self, obj):
return obj.client.ss_fra_retirement
def get_state_tax_after_credits(self, obj):
return obj.client.state_tax_after_credits
def get_state_tax_effrate(self, obj):
return obj.client.state_tax_effrate
def get_pension_name(self, obj):
return obj.client.pension_name
def get_pension_amount(self, obj):
return obj.client.pension_amount
def get_pension_start_date(self, obj):
return obj.client.pension_start_date
def get_employee_contributions_last_year(self, obj):
return obj.client.employee_contributions_last_year
def get_employer_contributions_last_year(self, obj):
return obj.client.employer_contributions_last_year
def get_total_contributions_last_year(self, obj):
return obj.client.total_contributions_last_year
def get_tax_transcript(self, obj):
try:
return obj.client.user.invitation.tax_transcript.url
except:
return None
def get_tax_transcript_data(self, obj):
if 'tax_transcript_data' in obj.client.regional_data:
return obj.client.regional_data.get('tax_transcript_data', None)
return None
def get_social_security_statement(self, obj):
if 'social_security_statement' in obj.client.regional_data:
return obj.client.regional_data.get('social_security_statement', None)
return None
def get_social_security_statement_data(self, obj):
if 'social_security_statement_data' in obj.client.regional_data:
return obj.client.regional_data.get('social_security_statement_data', None)
return None
def get_partner_social_security_statement(self, obj):
if 'partner_social_security_statement' in obj.client.regional_data:
return obj.client.regional_data.get('partner_social_security_statement', None)
return None
def get_partner_social_security_statement_data(self, obj):
if 'partner_social_security_statement_data' in obj.client.regional_data:
return obj.client.regional_data.get('partner_social_security_statement_data', None)
return None
class IndexSplitterSerializer(FieldParseSerializer,
serializers.HyperlinkedModelSerializer,
IndicesSerializerMixin,
ProjectResourceUrlSerializer):
author = UserSerializer(read_only=True)
url = serializers.SerializerMethodField()
scroll_size = serializers.IntegerField(min_value=0,
max_value=10000,
required=False)
description = serializers.CharField(help_text='Description of the task.',
required=True,
allow_blank=False)
query = serializers.JSONField(
help_text=
'Query used to filter the indices. Defaults to an empty query.',
required=False)
train_index = serializers.CharField(help_text='Name of the train index.',
allow_blank=False,
required=True,
validators=[
check_for_wildcards,
check_for_colons,
check_for_special_symbols,
check_for_banned_beginning_chars,
check_for_upper_case
])
test_index = serializers.CharField(help_text='Name of the test index.',
allow_blank=False,
required=True,
validators=[
check_for_wildcards,
check_for_colons,
check_for_special_symbols,
check_for_banned_beginning_chars,
check_for_upper_case
])
fields = serializers.ListField(
child=serializers.CharField(),
help_text=f'Empty fields chooses all posted indices fields.',
required=False)
task = TaskSerializer(read_only=True)
test_size = serializers.IntegerField(
help_text=
'Size of the test set. Represents a percentage with "random" or "original" distribution and a quantity with "equal" or "custom" distribution.',
required=False,
min_value=1,
max_value=10000)
fact = serializers.CharField(
required=False,
help_text=
"Name of the fact on which the test index distribution will base.")
str_val = serializers.CharField(
required=False,
help_text=
"Name of the fact value on which the test index distribution will base."
)
distribution = serializers.ChoiceField(
choices=LABEL_DISTRIBUTION,
default=LABEL_DISTRIBUTION[0][0],
required=False,
help_text=
'Distribution of the test set. Either "random", "original", "equal" or "custom".'
)
custom_distribution = serializers.JSONField(
default={},
help_text=
"A dictionary containing custom label distribution with keys as labels and values as quantities."
)
class Meta:
model = IndexSplitter
fields = ('id', 'url', 'author', 'description', 'indices',
'scroll_size', 'fields', 'query', 'train_index',
'test_index', "test_size", 'fact', 'str_val', 'distribution',
'custom_distribution', 'task')
fields_to_parse = ('fields', 'custom_distribution')
def validate_train_index(self, value):
""" Check that new_index does not exist """
open_indices, closed_indices = ElasticCore().get_indices()
if value in open_indices or value in closed_indices:
raise serializers.ValidationError(
f"{value} already exists, choose a different name for your train index"
)
return value
def validate_test_index(self, value):
""" Check that new_index does not exist """
open_indices, closed_indices = ElasticCore().get_indices()
if value in open_indices or value in closed_indices:
raise serializers.ValidationError(
f"{value} already exists, choose a different name for your test index"
)
return value
def validate_indices(self, value):
""" check if index is in the relevant project indices field """
project_obj = Project.objects.get(
id=self.context['view'].kwargs['project_pk'])
for index in value:
if index.get("name") not in project_obj.get_indices():
raise serializers.ValidationError(
f'Index "{index.get("name")}" is not contained in your project indices "{project_obj.get_indices()}"'
)
return value
def validate_fields(self, value):
''' check if fields included in the request are in the relevant project fields '''
project_fields = self._get_project_fields()
field_data = [field["path"] for field in project_fields]
for field in value:
if field not in field_data:
raise serializers.ValidationError(
f'The fields you are attempting to add to new indices are not in current project fields: {project_fields}'
)
return value
def validate_query(self, value):
val = json.loads(value)
if "query" not in json.loads(value):
raise serializers.ValidationError(
"Incorrect elastic query. Must contain field 'query'.")
return value
def validate(self, data):
fact = data.get("fact")
if data["distribution"] == "custom" and len(
data["custom_distribution"]) == 0:
raise serializers.ValidationError(
"field custom_distribution can not be empty with custom label distribution"
)
if fact == "" and data["distribution"] in [
"custom", "equal", "original"
]:
raise serializers.ValidationError(
'fact must be specified with "custom", "equal" or "original" distribution'
)
if data["distribution"] in ["custom", "equal", "original"]:
if "fields" in data and "texta_facts" not in data["fields"]:
project_fields = self._get_project_fields()
field_data = [field["path"] for field in project_fields]
if "texta_facts" not in field_data:
raise serializers.ValidationError(
f'Field texta_facts is required but it is not in project fields.: {project_fields}'
)
else:
data["fields"].append("texta_facts")
return data
def _get_project_fields(self):
project_obj = Project.objects.get(
id=self.context['view'].kwargs['project_pk'])
project_fields = ElasticCore().get_fields(
indices=project_obj.get_indices())
return project_fields
class TaskLogSLZ(serializers.ModelSerializer):
logs = serializers.JSONField()
class Meta:
model = HostApplyTaskLog
fields = ("created", "task_url", "operator", "status", "is_finished", "logs")
class AppCreatePreviewSLZ(AppMixin, serializers.Serializer):
""" 创建预览 """
name = serializers.CharField(write_only=True)
namespace_info = NamespaceInfoField(write_only=True, label="Namespace")
chart_version = serializers.PrimaryKeyRelatedField(
queryset=ChartVersion.objects.all(), write_only=True)
answers = HelmValueField(initial=[],
write_only=True,
label="Answers",
help_text="JSON format data",
source="get_answers",
style={
"base_template": "textarea.html",
"rows": 10
})
customs = HelmValueField(initial=[],
write_only=True,
label="Customs",
help_text="JSON format data",
source="get_customs",
style={
"base_template": "textarea.html",
"rows": 10
})
valuefile = YamlField(initial="",
write_only=True,
allow_blank=True,
default="",
label="ValueFile",
help_text="Yaml format data",
style={
"base_template": "textarea.html",
"rows": 10
})
content = serializers.JSONField(read_only=True)
notes = serializers.JSONField(read_only=True)
def create(self, validated_data):
""" 生成应用的预览数据，这个时候应用没有创建，release也没有创建 """
namespace_info = self.get_ns_info_by_id(
validated_data["namespace_info"])
check_cluster_perm(user=self.context["request"].user,
project_id=namespace_info["project_id"],
cluster_id=namespace_info["cluster_id"],
request=self.context["request"])
# prepare parameters
parameters = merge_rancher_answers(validated_data["get_answers"],
validated_data["get_customs"])
valuefile = get_valuefile_with_bcs_variable_injected(
access_token=self.context["request"].user.token.access_token,
project_id=namespace_info["project_id"],
namespace_id=namespace_info["id"],
valuefile=validated_data["valuefile"])
client = KubeHelmClient(helm_bin=settings.HELM_BIN)
try:
content, notes = client.template(
files=validated_data["chart_version"].files,
namespace=namespace_info["name"],
name=validated_data.get("name"),
parameters=parameters,
valuefile=valuefile,
)
except helm_exceptions.HelmBaseException as e:
raise ParseError(str(e))
# inject bcs info
now = datetime.datetime.now()
username = self.context["request"].user.username
content = bcs_info_injector.inject_bcs_info(
access_token=self.access_token,
project_id=self.project_id,
cluster_id=namespace_info["cluster_id"],
namespace_id=namespace_info["id"],
namespace=namespace_info["name"],
creator=username,
updator=username,
created_at=now,
updated_at=now,
resources=content,
version=validated_data["chart_version"].version)
return {
"content": preview_parse(content, namespace_info["name"]),
"notes": notes
}
class Meta:
fields = (
"name",
"namespace_info",
"chart_version",
"answers",
"customs",
"valuefile",
"content",
"notes",
)
read_only_fields = (
"content",
"notes",
)
class AppReleasePreviewSLZ(AppMixin, serializers.Serializer):
""" 发布预览 """
upgrade_verion = UpgradeVersionField(write_only=True, required=True)
answers = HelmValueField(initial=[],
write_only=True,
label="Answers",
help_text="JSON format data",
source="get_answers",
style={
"base_template": "textarea.html",
"rows": 10
})
customs = HelmValueField(initial=[],
write_only=True,
label="Customs",
help_text="JSON format data",
source="get_customs",
style={
"base_template": "textarea.html",
"rows": 10
})
valuefile = YamlField(initial="",
write_only=True,
allow_blank=True,
required=False,
default="",
label="ValueFile",
help_text="Yaml format data",
style={
"base_template": "textarea.html",
"rows": 10
})
content = serializers.JSONField(read_only=True)
notes = serializers.JSONField(read_only=True)
difference = serializers.JSONField(read_only=True)
chart_version_changed = serializers.BooleanField(read_only=True)
old_content = serializers.JSONField(read_only=True)
def create(self, validated_data):
""" 应用更新时的预览数据，这个时候目标release还没有创建 """
instance = App.objects.get(id=self.app_id)
check_cluster_perm(user=self.context["request"].user,
project_id=instance.project_id,
cluster_id=instance.cluster_id,
request=self.context["request"])
# 标记Chart中的values.yaml是否发生变化，用于提醒用户
chart_version_changed = False
# prepare parameters
parameters = merge_rancher_answers(validated_data["get_answers"],
validated_data["get_customs"])
chart_version_id = validated_data["upgrade_verion"]
chart_version_id = int(chart_version_id)
if chart_version_id == KEEP_TEMPLATE_UNCHANGED:
files = instance.release.chartVersionSnapshot.files
else:
chart_version_changed = True
chart_version = ChartVersion.objects.get(id=chart_version_id)
files = chart_version.files
valuefile = get_valuefile_with_bcs_variable_injected(
access_token=self.context["request"].user.token.access_token,
project_id=instance.project_id,
namespace_id=instance.namespace_id,
valuefile=validated_data["valuefile"])
client = KubeHelmClient(helm_bin=settings.HELM_BIN)
try:
content, notes = client.template(
files=files,
namespace=instance.namespace,
name=instance.name,
parameters=parameters,
valuefile=valuefile,
)
except helm_exceptions.HelmBaseException as e:
raise ParseError(str(e))
# inject bcs info
now = datetime.datetime.now()
content = bcs_info_injector.inject_bcs_info(
access_token=self.access_token,
project_id=instance.project_id,
cluster_id=instance.cluster_id,
namespace_id=instance.namespace_id,
namespace=instance.namespace,
creator=instance.creator,
updator=self.context["request"].user.username,
created_at=instance.created,
updated_at=now,
resources=content,
version=instance.release.chartVersionSnapshot.version,
)
# compute diff
old_content = instance.release.content
if not old_content:
old_content, _ = instance.render_app(
username=self.context["request"].user.username,
access_token=self.access_token)
difference = simple_diff(old_content, content, instance.namespace)
return {
"content": preview_parse(content, instance.namespace),
"notes": notes,
"difference": difference,
"chart_version_changed": chart_version_changed,
"old_content": old_content
}
class Meta:
fields = (
"name",
"namespace_info",
"chart_version",
"answers",
"customs",
"valuefile",
"content",
"notes",
"difference",
"chart_version_changed",
)
read_only_fields = (
"content",
"notes",
"chart_version_changed",
)
class AppDetailSLZ(AppBaseSLZ):
namespace_info = NamespaceInfoField(write_only=True, label="Namespace")
chart_info = serializers.JSONField(read_only=True, label="Chart Info")
chart_version = serializers.PrimaryKeyRelatedField(
queryset=ChartVersion.objects.all(), write_only=True)
release = ChartReleaseSLZ(read_only=True)
answers = HelmValueField(initial=[],
read_only=True,
label="Answers",
help_text="JSON format data",
source="get_answers",
style={
"base_template": "textarea.html",
"rows": 10
})
customs = HelmValueField(initial=[],
read_only=True,
label="Customs",
help_text="JSON format data",
source="get_customs",
style={
"base_template": "textarea.html",
"rows": 10
})
valuefile = YamlField(initial="",
read_only=True,
default="",
label="ValueFile",
help_text="Yaml format data",
source="get_valuefile",
style={
"base_template": "textarea.html",
"rows": 10
})
class Meta:
model = App
fields = (
"id",
"name",
"namespace",
"namespace_id",
"cluster_id",
"namespace_info",
"chart_version",
"chart_info",
"answers",
"customs",
"valuefile",
"project_id",
"chart",
"transitioning_result",
"transitioning_message",
"transitioning_on",
"transitioning_action",
"release",
"creator",
"updator",
"created",
"updated",
)
class WorkspaceCreateSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = Workspace
fields = ('id', 'url', 'workspace', 'category', 'status',
'current_task', 'metadata', 'input_minid', 'tasks',
'autostart')
task_type_h = ('Tasks to add to this workspace, as a JSON List. Example: '
'["WES", "JUPYTERHUB"]. Valid tasks are: {}'
''.format(','.join(TASK_TASK_NAMES.keys())))
input_minid_h = ('The minid that will serve as input for the first task '
'in the list.')
metadata_h = ('A dictionary object about the workspace. Suggested you '
'include: "grouping", "data_id", "data_set"')
autostart_h = 'Start first task on creation'
workspace = serializers.HyperlinkedRelatedField(read_only=True,
view_name='workspace-detail')
category = serializers.CharField(read_only=True)
status = serializers.CharField(read_only=True)
current_task = TaskSerializer(read_only=True)
tasks = serializers.JSONField(write_only=True, help_text=task_type_h,
default=['WES'])
input_minid = serializers.CharField(write_only=True,
help_text=input_minid_h)
metadata = serializers.JSONField(help_text=metadata_h)
autostart = serializers.BooleanField(help_text=autostart_h, required=False)
def validate_metadata(self, metadata):
if metadata is None or not isinstance(metadata, dict):
raise ValidationError("Wrong type, must be of type '{}'")
defaults = {
'grouping': 'ungrouped',
'data_id': 'unspecified',
'data_set': ''
}
defaults.update(metadata)
return defaults
def validate_tasks(self, tasks):
if not isinstance(tasks, list):
raise ValidationError('Wrong type, please add tasks in a list.')
if not tasks:
raise ValidationError('Please add at least one task')
return tasks
def validate_input_minid(self, minid):
valid_minids = ['ark:/99999/', 'ark:/57799/']
if not any([minid.startswith(v) for v in valid_minids]):
raise ValidationError('Must be a valid test or production Minid')
return minid
def create(self, validated_data):
user = self.context['request'].user
metadata = validated_data['metadata']
tasks = validated_data['tasks']
wname = ''
workspace = Workspace(name=wname, user=user,
metadata=metadata)
workspace.save()
try:
minid = add_minid(user, validated_data['input_minid'])
except ValueError as ve:
log.debug(ve)
raise ValidationError(str(ve))
first_task = Task(workspace=workspace, user=user,
category=tasks[0], status=TASK_READY,
name=TASK_METADATA[tasks[0]])
first_task.save()
first_task.input.add(minid)
for t in tasks[1:]:
tsk = Task(workspace=workspace, user=user, category=t,
status=TASK_WAITING, name=TASK_METADATA[t])
tsk.save()
if validated_data.get('autostart') is True:
workspace.current_task.start()
workspace.refresh_from_db()
return workspace
class RetirementPlanWritableSerializer(serializers.ModelSerializer):
expenses = serializers.JSONField(required=False,
help_text=RetirementPlan._meta.get_field('expenses').help_text,
validators=[make_json_list_validator('expenses', ExpensesSerializer)])
savings = serializers.JSONField(required=False,
help_text=RetirementPlan._meta.get_field('savings').help_text,
validators=[make_json_list_validator('savings', SavingsSerializer)])
initial_deposits = serializers.JSONField(required=False,
help_text=RetirementPlan._meta.get_field('initial_deposits').help_text,
validators=[make_json_list_validator('initial_deposits',
InitialDepositsSerializer)])
retirement_accounts = serializers.JSONField(required=False,
help_text=RetirementPlan._meta.get_field('retirement_accounts').help_text,
validators=[make_json_list_validator('retirement_accounts', RetirementAccountsSerializer)])
selected_life_expectancy = serializers.IntegerField(required=False)
retirement_age = serializers.IntegerField(required=False)
desired_risk = serializers.FloatField(required=False)
btc = serializers.FloatField(required=False)
atc = serializers.FloatField(required=False)
retirement_postal_code = serializers.CharField(max_length=10, required=False)
partner_data = serializers.JSONField(required=False, validators=[partner_data_validator])
civil_status = serializers.IntegerField(source='client.civil_status', required=False)
smoker = serializers.BooleanField(source='client.smoker', required=False)
daily_exercise = serializers.IntegerField(source='client.daily_exercise', required=False)
weight = serializers.FloatField(source='client.weight', required=False)
height = serializers.FloatField(source='client.height', required=False)
drinks = serializers.IntegerField(source='client.drinks', required=False)
balance = serializers.FloatField(required=False)
home_value = serializers.FloatField(source='client.home_value', required=False)
home_growth = serializers.FloatField(source='client.home_growth', required=False)
ss_fra_todays = serializers.FloatField(source='client.ss_fra_todays', required=False)
ss_fra_retirement = serializers.FloatField(source='client.ss_fra_retirement', required=False)
state_tax_after_credits = serializers.FloatField(source='client.state_tax_after_credits', required=False)
state_tax_effrate = serializers.FloatField(source='client.state_tax_effrate', required=False)
pension_name = serializers.CharField(source='client.pension_name', required=False)
pension_amount = serializers.FloatField(source='client.pension_amount', required=False)
pension_start_date = serializers.DateField(source='client.pension_start_date', required=False)
employee_contributions_last_year = serializers.FloatField(source='client.employee_contributions_last_year', required=False)
employer_contributions_last_year = serializers.FloatField(source='client.employer_contributions_last_year', required=False)
total_contributions_last_year = serializers.FloatField(source='client.total_contributions_last_year', required=False)
tax_transcript = serializers.FileField(source='client.user.invitation.tax_transcript', required=False, use_url=True)
social_security_statement = serializers.FileField(source='client.user.invitation.social_security_statement', required=False)
partner_social_security_statement = serializers.FileField(source='client.user.invitation.partner_social_security_statement', required=False)
date_of_estimate = serializers.DateField(required=False)
class Meta:
model = RetirementPlan
fields = (
'name',
'description',
'partner_plan',
'lifestyle',
'desired_income',
'income',
'volunteer_days',
'paid_days',
'same_home',
'same_location',
'retirement_postal_code',
'reverse_mortgage',
'retirement_home_style',
'retirement_home_price',
'beta_partner',
'expenses',
'savings',
'initial_deposits',
'income_growth',
'expected_return_confidence',
'retirement_age',
'btc',
'atc',
'max_employer_match_percent',
'desired_risk',
'selected_life_expectancy',
'partner_data',
'agreed_on',
'civil_status', # this field on the client not the RetirementPlan
'smoker',
'daily_exercise',
'weight',
'height',
'drinks',
'balance',
'home_value',
'home_growth',
'ss_fra_todays',
'ss_fra_retirement',
'state_tax_after_credits',
'state_tax_effrate',
'pension_name',
'pension_amount',
'pension_start_date',
'employee_contributions_last_year',
'employer_contributions_last_year',
'total_contributions_last_year',
'retirement_accounts',
'tax_transcript',
'social_security_statement',
'partner_social_security_statement',
'date_of_estimate',
)
def __init__(self, *args, **kwargs):
super(RetirementPlanWritableSerializer, self).__init__(*args, **kwargs)
# request-based validation
request = self.context.get('request')
if request.method == 'PUT':
for field in self.fields.values():
field.required = False
def validate(self, data):
"""
Define custom validator so we can confirm if same_home is not true, same_location is specified.
:param data:
:return:
"""
if (self.context.get('request').method == 'POST' and data.get('same_home', None) is None
and data.get('same_location', None) is None):
raise ValidationError("same_location must be specified if same_home is not True.")
return data
@transaction.atomic
def create(self, validated_data):
client = validated_data['client']
if not validated_data.get('retirement_postal_code', ''):
if validated_data['same_home'] or validated_data['same_location']:
postal_code = client.residential_address.post_code
validated_data['retirement_postal_code'] = postal_code
else:
raise ValidationError('retirement_postal_code required if not same_home and not same_location')
# Default the selected life expectancy to the calculated one if not specified.
if validated_data.get('selected_life_expectancy', None) is None:
validated_data['selected_life_expectancy'] = client.life_expectancy
if validated_data.get('retirement_age', None) is None:
validated_data['retirement_age'] = 67
if validated_data.get('btc', None) is None:
# defaults btc
validated_data['btc'] = validated_data['income'] * min(validated_data.get('max_employer_match_percent', 0), 0.04)
if validated_data.get('atc', None) is None:
# default atc
validated_data['atc'] = 0
if validated_data['reverse_mortgage'] and validated_data.get('retirement_home_price', None) is None:
home = client.external_assets.filter(type=ExternalAsset.Type.FAMILY_HOME.value).first()
if home:
validated_data['retirement_home_price'] = home.get_growth_valuation(timezone.now().date())
# Use the recommended risk for the client if no desired risk specified.
if validated_data.get('desired_risk', None) is None:
bas_scores = client.get_risk_profile_bas_scores()
validated_data['desired_risk'] = GoalSettingRiskProfile._recommend_risk(bas_scores)
plan = RetirementPlan.objects.create(**validated_data)
if plan.agreed_on: plan.generate_soa()
return plan
@transaction.atomic
def update(self, instance, validated_data):
"""
Override the default update because we have nested relations.
:param instance:
:param validated_data:
:return: The updated RetirementPlan
"""
if instance.agreed_on:
raise ValidationError("Unable to make changes to a plan that has been agreed on")
# Client civil_status check
if 'client' in validated_data:
if 'civil_status' in validated_data['client']:
instance.client.civil_status = validated_data['client']['civil_status']
if 'smoker' in validated_data['client']:
instance.client.smoker = validated_data['client']['smoker']
if 'drinks' in validated_data['client']:
instance.client.drinks = validated_data['client']['drinks']
if 'height' in validated_data['client']:
instance.client.height = validated_data['client']['height']
if 'weight' in validated_data['client']:
instance.client.weight = validated_data['client']['weight']
if 'daily_exercise' in validated_data['client']:
instance.client.daily_exercise = validated_data['client']['daily_exercise']
if 'home_value' in validated_data['client']:
instance.client.home_value = validated_data['client']['home_value']
if 'home_growth' in validated_data['client']:
instance.client.home_growth = validated_data['client']['home_growth']
if 'ss_fra_todays' in validated_data['client']:
instance.client.ss_fra_todays = validated_data['client']['ss_fra_todays']
if 'ss_fra_retirement' in validated_data['client']:
instance.client.ss_fra_retirement = validated_data['client']['ss_fra_retirement']
if 'state_tax_after_credits' in validated_data['client']:
instance.client.state_tax_after_credits = validated_data['client']['state_tax_after_credits']
if 'state_tax_effrate' in validated_data['client']:
instance.client.state_tax_effrate = validated_data['client']['state_tax_effrate']
if 'pension_name' in validated_data['client']:
instance.client.pension_name = validated_data['client']['pension_name']
if 'pension_amount' in validated_data['client']:
instance.client.pension_amount = validated_data['client']['pension_amount']
if 'pension_start_date' in validated_data['client']:
instance.client.pension_start_date = validated_data['client']['pension_start_date']
if 'employee_contributions_last_year' in validated_data['client']:
instance.client.employee_contributions_last_year = validated_data['client']['employee_contributions_last_year']
if 'employer_contributions_last_year' in validated_data['client']:
instance.client.employer_contributions_last_year = validated_data['client']['employer_contributions_last_year']
if 'total_contributions_last_year' in validated_data['client']:
instance.client.total_contributions_last_year = validated_data['client']['total_contributions_last_year']
if 'user' in validated_data['client']:
if 'tax_transcript' in validated_data['client']['user']['invitation']:
instance.client.user.invitation.tax_transcript = validated_data['client']['user']['invitation']['tax_transcript']
instance.client.user.invitation.save()
tmp_filename = '/tmp/' + str(uuid.uuid4()) + '.pdf'
with open(tmp_filename, 'wb+') as f:
for chunk in validated_data['client']['user']['invitation']['tax_transcript'].chunks():
f.write(chunk)
instance.client.regional_data['tax_transcript'] = instance.client.user.invitation.tax_transcript.url
instance.client.regional_data['tax_transcript_data'] = parse_tax_pdf(tmp_filename)
if 'social_security_statement' in validated_data['client']['user']['invitation']:
instance.client.user.invitation.social_security_statement = validated_data['client']['user']['invitation']['social_security_statement']
instance.client.user.invitation.save()
tmp_filename = '/tmp/' + str(uuid.uuid4()) + '.pdf'
with open(tmp_filename, 'wb+') as f:
for chunk in validated_data['client']['user']['invitation']['social_security_statement'].chunks():
f.write(chunk)
instance.client.regional_data['social_security_statement'] = instance.client.user.invitation.social_security_statement.url
instance.client.regional_data['social_security_statement_data'] = parse_ss_pdf(tmp_filename)
if 'partner_social_security_statement' in validated_data['client']['user']['invitation']:
instance.client.user.invitation.partner_social_security_statement = validated_data['client']['user']['invitation']['partner_social_security_statement']
instance.client.user.invitation.save()
tmp_filename = '/tmp/' + str(uuid.uuid4()) + '.pdf'
with open(tmp_filename, 'wb+') as f:
for chunk in validated_data['client']['user']['invitation']['partner_social_security_statement'].chunks():
f.write(chunk)
instance.client.regional_data['partner_social_security_statement'] = instance.client.user.invitation.partner_social_security_statement.url
instance.client.regional_data['partner_social_security_statement_data'] = parse_ss_pdf(tmp_filename)
instance.client.save()
for attr, value in validated_data.items():
if str(attr) != 'client':
# civil_status update is on client
setattr(instance, attr, value)
reverse_plan = getattr(instance, 'partner_plan_reverse', None)
if instance.partner_plan is not None and reverse_plan is not None and instance.partner_plan != reverse_plan:
emsg = "Partner plan relationship must be symmetric. " \
"I.e. Your selected partner plan must have you as it's partner"
raise ValidationError(emsg)
instance.save()
return instance
def get_tax_transcript_data(self, obj):
# parse_pdf
if obj.tax_transcript:
tmp_filename = '/tmp/' + str(uuid.uuid4()) + '.pdf'
with open(tmp_filename, 'wb+') as f:
for chunk in obj.tax_transcript.chunks():
f.write(chunk)
obj.tax_transcript_data = parse_tax_pdf(tmp_filename)
logger.error(obj.tax_transcript_data)
return obj.tax_transcript_data
return None
def get_social_security_statement_data(self, obj):
if obj.social_security_statement:
tmp_filename = '/tmp/' + str(uuid.uuid4()) + '.pdf'
with open(tmp_filename, 'wb+') as f:
for chunk in obj.social_security_statement.chunks():
f.write(chunk)
obj.client.regional_data['social_security_statement_data'] = parse_ss_pdf(tmp_filename)
obj.client.save()
return obj.social_security_statement_data
return None
def get_partner_social_security_statement_data(self, obj):
if obj.partner_social_security_statement:
tmp_filename = '/tmp/' + str(uuid.uuid4()) + '.pdf'
with open(tmp_filename, 'wb+') as f:
for chunk in obj.partner_social_security_statement.chunks():
f.write(chunk)
obj.client.regional_data['partner_social_security_statement_data'] = parse_ss_pdf(tmp_filename)
obj.client.save()
return obj.client.regional_data['partner_social_security_statement_data']
return None
class DumpFixtureSerializer(serializers.Serializer):
app_name = serializers.CharField(required=True)
model_name = serializers.CharField(required=True)
file_name = serializers.CharField(required=True)
filter_options = serializers.JSONField()
class AdviceFeedActionSerializer(serializers.Serializer):
label = serializers.CharField()
type = serializers.CharField()
url = serializers.CharField()
data = serializers.JSONField()
class ClientUpdateSerializer(serializers.ModelSerializer):
"""
Write PUT update requests only
"""
qs = RiskProfileAnswer.objects.all()
risk_profile_responses = serializers.PrimaryKeyRelatedField(many=True,
queryset=qs,
required=False)
residential_address = AddressUpdateSerializer()
regional_data = serializers.JSONField()
question_one = serializers.IntegerField(required=True)
answer_one = serializers.CharField(required=True)
question_two = serializers.IntegerField(required=True)
answer_two = serializers.CharField(required=True)
class Meta:
model = Client
fields = (
'employment_status',
RESIDENTIAL_ADDRESS_KEY,
'income',
'other_income',
'occupation',
'industry_sector',
'employer_type',
'student_loan',
'employer',
'civil_status',
'risk_profile_responses',
'betasmartz_agreement',
'advisor_agreement',
'phone_num',
'regional_data',
'smoker',
'daily_exercise',
'weight',
'height',
'drinks',
'date_of_birth',
'question_one',
'answer_one',
'question_two',
'answer_two',
)
def validate(self, data):
request = self.context.get('request')
user = request.user
# no user is create request for initial registration
# SecurityAnswer checks
if data.get('question_one') == data.get('question_two'):
logger.error('ClientUpdateSerializer given matching questions %s' %
data.get('question_one'))
raise serializers.ValidationError(
{'question_two': 'Questions must be unique'})
try:
sa1 = SecurityAnswer.objects.get(pk=data.get('question_one'))
if sa1.user != user:
logger.error(
'SecurityAnswer not found for user %s and question %s with ClientUpdateSerializer'
% (user.email, data.get('question_one')))
raise serializers.ValidationError(
{'question_one': 'User does not own given question'})
except:
logger.error('ClientUpdateSerializer question %s not found' %
data.get('question_one'))
raise serializers.ValidationError(
{'question_one': 'Question not found'})
if not sa1.check_answer(data.get('answer_one')):
logger.error('ClientUpdateSerializer answer two was wrong')
raise serializers.ValidationError({'answer_one': 'Wrong answer'})
try:
sa2 = SecurityAnswer.objects.get(pk=data.get('question_two'))
if sa2.user != user:
logger.error(
'SecurityAnswer not found for user %s and question %s with ClientUpdateSerializer'
% (user.email, data.get('question_two')))
raise serializers.ValidationError(
{'question_two': 'User does not own given question'})
except:
logger.error('ClientUpdateSerializer question %s not found' %
data.get('question_two'))
raise serializers.ValidationError(
{'question_two': 'Question not found'})
if not sa2.check_answer(data.get('answer_two')):
logger.error('ClientUpdateSerializer answer two was wrong')
raise serializers.ValidationError({'answer_two': 'Wrong answer'})
return data
def validate_phone_num(self, phone_num):
serializer = PhoneNumberValidationSerializer(
data={'number': phone_num})
if not serializer.is_valid():
raise serializers.ValidationError('Invalid phone number')
return serializer.validated_data['number']
def update(self, instance, validated_data):
add_data = validated_data.pop(RESIDENTIAL_ADDRESS_KEY, None)
if add_data is not None:
address_ser = AddressUpdateSerializer(data=add_data)
address_ser.is_valid(raise_exception=True)
validated_data[RESIDENTIAL_ADDRESS_KEY] = address_ser.save()
return super(ClientUpdateSerializer,
self).update(instance, validated_data)
class OCIBuildImageSerializer(serializers.Serializer):
"""
Serializer for building an OCI container image from a Containerfile.
The Containerfile can either be specified via an artifact url, or a new file can be uploaded.
A repository must be specified, to which the container image content will be added.
"""
containerfile_artifact = RelatedField(
many=False,
lookup_field="pk",
view_name="artifacts-detail",
queryset=Artifact.objects.all(),
help_text=
_("Artifact representing the Containerfile that should be used to run buildah."
),
)
containerfile = serializers.FileField(
help_text=_(
"An uploaded Containerfile that should be used to run buildah."),
required=False,
)
tag = serializers.CharField(
required=False,
default="latest",
help_text="A tag name for the new image being built.")
artifacts = serializers.JSONField(
required=False,
help_text=
"A JSON string where each key is an artifact href and the value is it's "
"relative path (name) inside the /pulp_working_directory of the build container "
"executing the Containerfile.",
)
def __init__(self, *args, **kwargs):
"""Initializer for OCIBuildImageSerializer."""
super().__init__(*args, **kwargs)
self.fields["containerfile_artifact"].required = False
def validate(self, data):
"""Validates that all the fields make sense."""
data = super().validate(data)
if "containerfile" in data:
if "containerfile_artifact" in data:
raise serializers.ValidationError(
_("Only one of 'containerfile' and 'containerfile_artifact' may be specified."
))
data["containerfile_artifact"] = Artifact.init_and_validate(
data.pop("containerfile"))
elif "containerfile_artifact" in data:
data["containerfile_artifact"].touch()
else:
raise serializers.ValidationError(
_("'containerfile' or 'containerfile_artifact' must "
"be specified."))
artifacts = {}
if "artifacts" in data:
for url, relative_path in data["artifacts"].items():
if os.path.isabs(relative_path):
raise serializers.ValidationError(
_("Relative path cannot start with '/'. "
"{0}").format(relative_path))
artifactfield = RelatedField(
view_name="artifacts-detail",
queryset=Artifact.objects.all(),
source="*",
initial=url,
)
try:
artifact = artifactfield.run_validation(data=url)
artifact.touch()
artifacts[artifact.pk] = relative_path
except serializers.ValidationError as e:
# Append the URL of missing Artifact to the error message
e.detail[0] = "%s %s" % (e.detail[0], url)
raise e
data["artifacts"] = artifacts
return data
class Meta:
fields = (
"containerfile_artifact",
"containerfile",
"repository",
"tag",
"artifacts",
)
class ErrorResponseSerializer(serializers.Serializer):
summary = serializers.CharField(required=True)
detail = serializers.CharField(required=True)
errors = serializers.JSONField(required=True)
class RateSerializer (serializers.Serializer):
rates = serializers.JSONField()
class JobTypeRevisionSerializerV5(JobTypeRevisionBaseSerializer):
"""Converts job type revision model fields to REST output."""
interface = serializers.JSONField(default=dict, source='manifest')
created = serializers.DateTimeField()
class MigrationPlanSerializer(ModelSerializer):
"""Serializer for migration plan model."""
pulp_href = IdentityField(view_name='migration-plans-detail')
plan = serializers.JSONField(
help_text=_('Migration Plan in JSON format'),
required=True,
)
class Meta:
fields = ModelSerializer.Meta.fields + ('plan', )
model = MigrationPlan
def validate(self, data):
"""
Validate that the Serializer contains valid data.
Validates JSON structure of migration_plan.
Checks pulp2 and pulp3 plugins are installed.
"""
schema = json.loads(SCHEMA)
validator = Draft7Validator(schema)
if isinstance(data['plan'], str):
loaded_plan = json.loads(data['plan'])
elif isinstance(data['plan'], dict):
loaded_plan = data['plan']
else:
raise serializers.ValidationError(
_("Must provide a (JSON-encoded) string or dict for 'plan', not list"
))
err = []
for error in sorted(validator.iter_errors(loaded_plan), key=str):
err.append(error.message)
if err:
raise serializers.ValidationError(
_("Provided Migration Plan format is invalid:'{}'".format(
err)))
plugins_to_migrate = set()
for plugin_type in loaded_plan['plugins']:
plugins_to_migrate.add(plugin_type['type'])
if len(loaded_plan['plugins']) != len(plugins_to_migrate):
raise serializers.ValidationError(
_("Provided Migration Plan contains same plugin type specified more that once."
))
# MongoDB connection initialization
connection.initialize()
db = connection.get_database()
for plugin in plugins_to_migrate:
plugin_migrator = PLUGIN_MIGRATORS.get(plugin)
if not plugin_migrator:
raise serializers.ValidationError(
_("Migration of {} plugin is not supported.".format(
plugin)))
if plugin_migrator.pulp3_plugin not in INSTALLED_PULP_PLUGINS:
raise serializers.ValidationError(
_("Plugin {} is not installed in pulp3.".format(plugin)))
try:
db.command("collstats", plugin_migrator.pulp2_collection)
except OperationFailure:
raise serializers.ValidationError(
_("Plugin {} is not installed in pulp2.".format(plugin)))
data['plan'] = loaded_plan
return data
class CollectionVersionSerializer(SingleArtifactContentSerializer,
ContentChecksumSerializer):
"""
A serializer for CollectionVersion Content.
"""
id = serializers.UUIDField(source="pk",
help_text="A collection identifier.")
authors = serializers.ListField(
help_text=_("A list of the CollectionVersion content's authors."),
child=serializers.CharField(max_length=64),
)
contents = serializers.JSONField(
help_text=_("A JSON field with data about the contents."))
dependencies = serializers.JSONField(help_text=_(
"A dict declaring Collections that this collection requires to be installed for it to "
"be usable."))
description = serializers.CharField(
help_text=_("A short summary description of the collection."),
allow_blank=True)
docs_blob = serializers.JSONField(help_text=_(
"A JSON field holding the various documentation blobs in the collection."
))
manifest = serializers.JSONField(
help_text=_("A JSON field holding MANIFEST.json data."))
files = serializers.JSONField(
help_text=_("A JSON field holding FILES.json data."))
documentation = serializers.CharField(
help_text=_("The URL to any online docs."),
allow_blank=True,
max_length=2000)
homepage = serializers.CharField(
help_text=_("The URL to the homepage of the collection/project."),
allow_blank=True,
max_length=2000,
)
issues = serializers.CharField(
help_text=_("The URL to the collection issue tracker."),
allow_blank=True,
max_length=2000)
license = serializers.ListField(
help_text=_("A list of licenses for content inside of a collection."),
child=serializers.CharField(max_length=32),
)
name = serializers.CharField(help_text=_("The name of the collection."),
max_length=64)
namespace = serializers.CharField(
help_text=_("The namespace of the collection."), max_length=64)
repository = serializers.CharField(
help_text=_("The URL of the originating SCM repository."),
allow_blank=True,
max_length=2000)
tags = TagNestedSerializer(many=True, read_only=True)
version = serializers.CharField(
help_text=_("The version of the collection."), max_length=128)
requires_ansible = serializers.CharField(
help_text=_("The version of Ansible required to use the collection. "
"Multiple versions can be separated with a comma."),
allow_null=True,
required=False,
max_length=255,
)
class Meta:
fields = (tuple(
set(SingleArtifactContentSerializer.Meta.fields) -
{"relative_path"}) + ContentChecksumSerializer.Meta.fields + (
"id",
"authors",
"contents",
"dependencies",
"description",
"docs_blob",
"manifest",
"files",
"documentation",
"homepage",
"issues",
"license",
"name",
"namespace",
"repository",
"tags",
"version",
"requires_ansible",
))
model = CollectionVersion
class StrikeDetailsSerializer(StrikeSerializer):
"""Converts strike model fields to REST output"""
configuration = serializers.JSONField()
class DetailedHealthStatsSerializer(serializers.ModelSerializer):
values = serializers.JSONField()
class Meta:
model = DetailedHealthStatsModel
fields = ('name', 'values')
class SourcesSerializer(serializers.ModelSerializer):
"""Serializer for the Sources model."""
source_id = serializers.IntegerField(required=False, read_only=True)
name = serializers.CharField(max_length=256,
required=False,
allow_null=False,
allow_blank=False,
read_only=True)
authentication = serializers.JSONField(required=False)
billing_source = serializers.JSONField(required=False)
source_type = serializers.CharField(max_length=50,
required=False,
allow_null=False,
allow_blank=False,
read_only=True)
koku_uuid = serializers.CharField(max_length=512,
required=False,
allow_null=False,
allow_blank=False,
read_only=True)
source_uuid = serializers.CharField(max_length=512,
required=False,
allow_null=False,
allow_blank=False,
read_only=True)
# pylint: disable=too-few-public-methods
class Meta:
"""Metadata for the serializer."""
model = Sources
fields = ('source_id', 'name', 'source_type', 'authentication',
'billing_source', 'koku_uuid', 'source_uuid')
def _validate_billing_source(self, provider_type, billing_source):
"""Validate billing source parameters."""
if provider_type == 'AWS':
if not billing_source.get('bucket'):
raise SourcesStorageError('Missing AWS bucket.')
elif provider_type == 'AZURE':
data_source = billing_source.get('data_source')
if not data_source:
raise SourcesStorageError('Missing AZURE data_source.')
if not data_source.get('resource_group'):
raise SourcesStorageError('Missing AZURE resource_group')
if not data_source.get('storage_account'):
raise SourcesStorageError('Missing AZURE storage_account')
def _update_billing_source(self, instance, billing_source):
if instance.source_type not in ('AWS', 'AZURE'):
raise SourcesStorageError(f'Option not supported by '
f'source type {instance.source_type}.')
self._validate_billing_source(instance.source_type, billing_source)
instance.billing_source = billing_source
if instance.koku_uuid:
instance.pending_update = True
instance.save(update_fields=['billing_source', 'pending_update'])
else:
instance.save()
def _update_authentication(self, instance, authentication):
if instance.source_type not in ('AZURE', ):
raise SourcesStorageError(f'Option not supported by '
f'source type {instance.source_type}.')
auth_dict = instance.authentication
if not auth_dict.get('credentials'):
raise SourcesStorageError('Missing credentials key')
subscription_id = authentication.get('credentials',
{}).get('subscription_id')
auth_dict['credentials']['subscription_id'] = subscription_id
instance.authentication = auth_dict
if instance.koku_uuid:
instance.pending_update = True
instance.save(update_fields=['authentication', 'pending_update'])
else:
instance.save()
def update(self, instance, validated_data):
"""Update a Provider instance from validated data."""
billing_source = validated_data.get('billing_source')
authentication = validated_data.get('authentication')
if billing_source:
self._update_billing_source(instance, billing_source)
if authentication:
self._update_authentication(instance, authentication)
return instance
class ContractSerializer(serializers.ModelSerializer):
contract_details = serializers.JSONField(write_only=True)
class Meta:
model = Contract
fields = (
'id',
'user',
'address',
'owner_address',
'state',
'created_date',
'source_code',
'bytecode',
'abi',
'compiler_version',
'balance',
'cost',
'name',
'contract_type',
'contract_details',
)
extra_kwargs = {
'user': {
'read_only': True
},
'address': {
'read_only': True
},
'owner_address': {
'read_only': True
},
'created_date': {
'read_only': True
},
'source_code': {
'read_only': True
},
'bytecode': {
'read_only': True
},
'abi': {
'read_only': True
},
'compiler_version': {
'read_only': True
},
'balance': {
'read_only': True
},
'cost': {
'read_only': True
},
'last_check': {
'read_only': True
},
'next_check': {
'read_only': True
},
}
def create(self, validated_data):
validated_data['user'] = self.context['request'].user
validated_data['state'] = 'CREATED'
response = requests.post('http://{}/get_key/'.format(SIGNER)).content
print(response)
validated_data['owner_address'] = json.loads(response.decode())['addr']
contract_type = validated_data['contract_type']
details_serializer = self.get_details_serializer(contract_type)(
context=self.context)
contract_details = validated_data.pop('contract_details')
details_serializer.validate(contract_details)
validated_data['cost'] = Contract.get_details_model(
contract_type).calc_cost(contract_details)
contract = super().create(validated_data)
details_serializer.create(contract, contract_details)
return contract
def to_representation(self, contract):
res = super().to_representation(contract)
res['contract_details'] = self.get_details_serializer(
contract.contract_type)(context=self.context).to_representation(
contract.get_details())
return res
def update(self, contract, validated_data):
validated_data.pop('contract_type', None)
if contract.state != 'CREATED':
raise PermissionDenied()
if 'state' in validated_data and validated_data['state'] not in (
'CREATED', 'WAITING_FOR_PAYMENT'):
del validated_data['state']
contract_type = contract.contract_type
contract_details = validated_data.pop('contract_details', None)
if contract_details:
details_serializer = self.get_details_serializer(contract_type)(
context=self.context)
details_serializer.validate(contract_details)
validated_data['cost'] = contract.get_details().calc_cost(
contract_details)
details_serializer.update(contract, contract.get_details(),
contract_details)
return super().update(contract, validated_data)
def get_details_serializer(self, contract_type):
return [
ContractDetailsLastwillSerializer,
ContractDetailsLostKeySerializer,
ContractDetailsDelayedPaymentSerializer,
ContractDetailsPizzaSerializer,
][contract_type]
class HistoryRecordDetailSerializer(serializers.HyperlinkedModelSerializer):
ret = serializers.JSONField(True)
msg = serializers.JSONField(True)
data = serializers.JSONField(True)
file_id = serializers.JSONField(True)
file_name = serializers.JSONField(True)
file_url = serializers.JSONField(True)
file_type = serializers.JSONField(True)
inspection_result = serializers.JSONField(True)
max_sensitivity_type = serializers.JSONField(True)
max_sensitivity_level = serializers.JSONField(True)
violence_percent = serializers.JSONField(True)
violence_sensitivity_level = serializers.JSONField(True)
porn_percent = serializers.JSONField(True)
porn_sensitivity_level = serializers.JSONField(True)
politics_percent = serializers.JSONField(True)
politics_sensitivity_level = serializers.JSONField(True)
public_percent = serializers.JSONField(True)
public_character_level = serializers.JSONField(True)
content = serializers.JSONField(True)
upload_time = serializers.JSONField(True)
process_status = serializers.JSONField(True)
system_id = serializers.JSONField(True)
channel_id = serializers.JSONField(True)
user_id = serializers.JSONField(True)
class Meta:
model = HistoryRecord
fields = ('id', 'file_id', 'file_name', 'file_url', 'file_type',
'inspection_result', 'max_sensitivity_type',
'max_sensitivity_level', 'violence_percent',
'violence_sensitivity_level', 'porn_percent',
'porn_sensitivity_level', 'politics_percent',
'politics_sensitivity_level', 'public_percent',
'public_character_level', 'content', 'upload_time',
'process_status', 'system_id', 'channel_id', 'user_id',
'ret', 'msg', 'data')
def clean_json(self, obj):
return obj.ret, obj.msg, obj.data, obj.file_id, obj.file_name, obj.file_url,
obj.file_type, obj.inspection_result, obj.max_sensitivity_type,
obj.max_sensitivity_level, obj.violence_percent, obj.violence_sensitivity_level,
obj.porn_percent, obj.porn_sensitivity_level, obj.politics_percent,
obj.politics_sensitivity_level, obj.public_percent, obj.public_character_level,
obj.content, obj.upload_time, obj.process_status, obj.system_id,
obj.channel_id, obj.user_id
