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