import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
import org.openecomp.sdc.common.log.wrappers.Logger;
import org.springframework.stereotype.Controller;
+import org.apache.commons.lang3.StringUtils;
@Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
@Path("/v1/catalog/data-types")
throw new OperationException(ActionStatus.INVALID_MODEL,
String.format("Property model is not the same as the data type model. Must be '%s'", model));
}
+ if (StringUtils.isEmpty(dataType.getModel())) {
+ dataType.setModel("SDC AID");
+ }
final PropertyDefinitionDto property = dataTypeOperation.createProperty(id, propertyDefinitionDto);
dataTypeOperation.addPropertyToAdditionalTypeDataType(dataType, property);
dataTypeBusinessLogic.updateApplicationDataTypeCache(id);
import java.util.List;
import lombok.Data;
-import org.openecomp.sdc.be.model.PropertyConstraint;
@Data
public class PropertyDefinitionDto {
private Boolean required;
private Object value;
private Object defaultValue;
- private List<PropertyConstraint> constraints;
+ private List<Object> constraints;
}
package org.openecomp.sdc.be.model.mapper;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
import com.google.gson.Gson;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.commons.collections4.CollectionUtils;
import org.openecomp.sdc.be.model.PropertyConstraint;
import org.openecomp.sdc.be.model.PropertyDefinition;
import org.openecomp.sdc.be.model.dto.PropertyDefinitionDto;
+import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class PropertyDefinitionDtoMapper {
+ private static final Logger LOGGER = LoggerFactory.getLogger(PropertyDefinitionDtoMapper.class);
+
public static PropertyDefinition mapTo(final PropertyDefinitionDto propertyDefinitionDto) {
final var propertyDefinition = new PropertyDefinition();
propertyDefinition.setUniqueId(propertyDefinitionDto.getUniqueId());
}
if (CollectionUtils.isNotEmpty(propertyDefinitionDto.getConstraints())) {
final List<PropertyConstraint> propertyConstraints = new ArrayList<>();
+
+ propertyDefinitionDto.getConstraints().forEach(rawConstraint -> {
+ ObjectMapper mapper = new ObjectMapper();
+
+ SimpleModule module = new SimpleModule("customDeserializationModule");
+ module.addDeserializer(PropertyConstraint.class, new PropertyOperation.PropertyConstraintJacksonDeserializer());
+ mapper.registerModule(module);
+ mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+ try {
+ PropertyConstraint constraint =
+ mapper.readValue(new Gson().toJson(rawConstraint, Map.class), PropertyConstraint.class);
+ propertyConstraints.add(constraint);
+ } catch (JsonProcessingException e) {
+ LOGGER.error("Could not parse constraint '{}' for property '{}'", rawConstraint, propertyDefinitionDto.getName());
+ }
+ });
propertyDefinition.setConstraints(propertyConstraints);
- propertyConstraints.addAll(propertyDefinitionDto.getConstraints());
}
propertyDefinition.setDescription(propertyDefinitionDto.getDescription());
propertyDefinition.setValue(new Gson().toJson(propertyDefinitionDto.getValue()));
propertyDefinitionDto.setRequired(propertyDefinition.getRequired());
propertyDefinitionDto.setSchemaType(propertyDefinition.getSchemaType());
if (CollectionUtils.isNotEmpty(propertyDefinition.getConstraints())) {
- final List<PropertyConstraint> propertyConstraints = new ArrayList<>();
- propertyDefinitionDto.setConstraints(propertyConstraints);
- propertyConstraints.addAll(propertyDefinition.getConstraints());
+ propertyDefinitionDto.setConstraints(new ArrayList<>(propertyDefinition.getConstraints()));
}
propertyDefinitionDto.setValue(new Gson().fromJson(propertyDataDefinition.getValue(), Object.class));
propertyDefinitionDto.setDefaultValue(new Gson().fromJson(propertyDataDefinition.getDefaultValue(), Object.class));
final PropertyData propertyData = resultEither.left().value();
final PropertyDataDefinition propertyDataDefinition = propertyData.getPropertyDataDefinition();
propertyDataDefinition.setName(propertyName);
+ propertyDataDefinition.setPropertyConstraints(propertyData.getConstraints());
return PropertyDefinitionDtoMapper.mapFrom(propertyDataDefinition);
}
}
}
this.constraints = new Array();
- if (changes.propertyConstraints && changes.propertyConstraints.currentValue) {
- changes.propertyConstraints.currentValue.forEach((constraint: any) => {
- this.constraints.push(this.getConstraintFromPropertyBEModel(constraint));
- });
+ if(changes.propertyConstraints) {
+ if (changes.propertyConstraints.currentValue) {
+ changes.propertyConstraints.currentValue.forEach((constraint: any) => {
+ this.constraints.push(this.getConstraintFromPropertyBEModel(constraint));
+ });
+ }
}
}
[readOnly]="readOnly">
</textarea>
</div>
- <div class="default-value-container i-sdc-form-item" *ngIf="showDefaultValue()">
+ <div class="constraints-section i-sdc-form-item">
+ <label class="i-sdc-form-label" *ngIf="property ? property.constraints: false">Constraints</label>
+ <ng-container>
+ <app-constraints [propertyConstraints]="property ? property.constraints ? property.constraints : null : null"
+ [isViewOnly]="readOnly"
+ [propertyType]="property ? property.type : typeForm.value"
+ (onConstraintChange)="onConstraintChange($event)">
+ </app-constraints>
+ </ng-container>
+ </div>
+
+ <div class="default-value-container i-sdc-form-item" *ngIf="showDefaultValue()">
<label class="i-sdc-form-label">{{'PROPERTY_DEFAULT_VALUE_LABEL' | translate}}</label>
<ng-container *ngIf="!readOnly">
<input type="checkbox" formControlName="hasDefaultValue" [attr.disabled]="readOnly ? readOnly : null"/> {{'PROPERTY_SET_DEFAULT_VALUE_MSG' | translate}}
import {FormsModule, ReactiveFormsModule} from "@angular/forms";
import {TranslateModule} from "../../../../shared/translator/translate.module";
import {UiElementsModule} from "../../../../components/ui/ui-elements.module";
-import {Component, Input} from "@angular/core";
+import {Component, Input, NO_ERRORS_SCHEMA} from "@angular/core";
import {DataTypeModel} from "../../../../../models/data-types";
import {SchemaPropertyGroupModel} from "../../../../../models/schema-property";
import {DataTypeService} from "../../../../services/data-type.service";
TranslateModule,
UiElementsModule
],
+ schemas: [NO_ERRORS_SCHEMA],
providers: [
{provide: DataTypeService, useValue: dataTypeServiceMock},
{provide: TranslateService, useValue: translateServiceMock}
@Output() onValidityChange: EventEmitter<PropertyValidationEvent> = new EventEmitter<PropertyValidationEvent>();
+ private validConstraints: boolean = true;
private valueChangesSub: Subscription;
private descriptionForm: FormControl = new FormControl(undefined);
private requiredForm: FormControl = new FormControl(false, Validators.required);
}
return null;
});
+
hasDefaultValueForm: FormControl = new FormControl(false, Validators.required);
defaultValueForm: FormControl = new FormControl(undefined);
+ constraintsForm: FormControl = new FormControl(undefined);
formGroup: FormGroup = new FormGroup({
'name': this.nameForm,
'description': this.descriptionForm,
'schema': this.schemaForm,
'defaultValue': this.defaultValueForm,
'hasDefaultValue': this.hasDefaultValueForm,
+ 'constraints': this.constraintsForm,
});
isLoading: boolean = false;
this.showSchema = this.typeNeedsSchema();
this.updateDataType();
this.resetDefaultValue();
+ if (this.property) {
+ this.property.constraints = [];
+ }
}
private updateDataType(): void {
this.showSchema = this.typeNeedsSchema();
this.requiredForm.setValue(this.property.required);
this.schemaForm.setValue(this.property.schemaType);
+ this.constraintsForm.setValue(this.property.constraints);
this.initDefaultValueForm();
}
private emitValidityChange(): void {
const isValid: boolean = this.formGroup.valid;
this.onValidityChange.emit({
- isValid: isValid,
+ isValid: isValid && this.validConstraints,
property: isValid ? this.buildPropertyFromForm() : undefined
});
}
const property = new PropertyBEModel();
property.name = this.nameForm.value;
property.type = this.typeForm.value;
+ property.constraints = this.constraintsForm.value;
if (this.schemaForm.value) {
property.schemaType = this.schemaForm.value;
}
return new SchemaPropertyGroupModel(schemaProperty);
}
+ onConstraintChange = (constraints: any): void => {
+ if (this.property) {
+ if (!this.property.constraints) {
+ this.property.constraints = [];
+ }
+ this.property.constraints = constraints.constraints;
+ }
+ else {
+ this.constraintsForm.setValue(constraints.constraints);
+ }
+ this.validConstraints = constraints.valid;
+ this.onValidityChange.emit({
+ isValid: constraints.valid,
+ property: constraints.valid ? this.buildPropertyFromForm() : undefined
+ });
+ }
}
export class PropertyValidationEvent {
import {AddPropertyComponent, PropertyValidationEvent} from "./add-property/add-property.component";
import {IWorkspaceViewModelScope} from "../../../../view-models/workspace/workspace-view-model";
import {SdcUiServices} from "onap-ui-angular/dist";
+import {ToscaTypeHelper} from "../../../../utils/tosca-type-helper";
@Component({
selector: 'app-type-workspace-properties',
this.properties = properties.map(value => {
const property = new PropertyBEModel(value);
if (property.defaultValue) {
- property.defaultValue = JSON.parse(property.defaultValue);
+ if (!this.isTypeSimple(property.type) && typeof property.defaultValue === 'string') {
+ property.defaultValue = JSON.parse(property.defaultValue);
+ } else {
+ property.defaultValue = property.defaultValue;
+ }
}
-
return property;
});
this.filteredProperties = Array.from(this.properties);
this.sort();
}
+
+ public isTypeSimple(value:any): boolean {
+ return ToscaTypeHelper.isTypeSimple(value);
+ }
+
+ onConstraintChange = (constraints: any): void => {
+ if (!this.$scope.invalidMandatoryFields) {
+ this.$scope.footerButtons[0].disabled = !constraints.valid;
+ } else {
+ this.$scope.footerButtons[0].disabled = this.$scope.invalidMandatoryFields;
+ }
+ if (!constraints.constraints || constraints.constraints.length == 0) {
+ this.$scope.editPropertyModel.property.propertyConstraints = null;
+ this.$scope.editPropertyModel.property.constraints = null;
+ return;
+ }
+ this.$scope.editPropertyModel.property.propertyConstraints = this.serializePropertyConstraints(constraints.constraints);
+ this.$scope.editPropertyModel.property.constraints = constraints.constraints;
+ }
+
+ private serializePropertyConstraints(constraints: any[]): string[] {
+ if (constraints) {
+ let stringConstraints = new Array();
+ constraints.forEach((constraint) => {
+ stringConstraints.push(JSON.stringify(constraint));
+ })
+ return stringConstraints;
+ }
+ return null;
+ }
}
interface TableHeader {
import {AddPropertyComponent} from './type-workspace-properties/add-property/add-property.component';
import {InterfaceOperationHandlerModule} from "../composition/interface-operatons/operation-creator/interface-operation-handler.module";
import {AutoCompleteModule} from "onap-ui-angular/dist/autocomplete/autocomplete.module";
+import {ConstraintsModule} from "../properties-assignment/constraints/constraints.module";
@NgModule({
imports: [
InterfaceOperationHandlerModule,
NgxDatatableModule,
SvgIconModule,
- AutoCompleteModule
+ AutoCompleteModule,
+ ConstraintsModule
],
declarations: [
TypeWorkspaceComponent,
}
public createProperty(id: string, property: PropertyBEModel): Observable<PropertyBEModel> {
- const url = `${this.dataTypeUrl}/${id}/properties`
+ const url = `${this.dataTypeUrl}/${id}/properties`;
return this.httpClient.post<PropertyBEModel>(url, property);
}
*/
import {DataTypeModel, PropertyBEModel} from "../models";
+import {Constraint, ConstraintTypes} from "../ng2/pages/properties-assignment/constraints/constraints.component";
import {load} from 'js-yaml';
export class ServiceDataTypeReader {
property.type = properties[key]["type"];
property.schemaType = properties[key]["schema"];
property.required = properties[key]["required"];
+ const constraints = properties[key]["constraints"];
+
+ if (constraints) {
+ property.constraints = new Array();
+ let constraintArray = new Array();
+ Object.keys(constraints).forEach((constrainKey) => {
+ Object.keys(constraints[constrainKey]).forEach((kc) => {
+ let newConstraint = this.mapValuesToConstraint(<ConstraintTypes>kc, constraints[constrainKey][kc]);
+ let jsonObject = this.getConstraintFormat(newConstraint);
+ constraintArray.push(jsonObject);
+
+ });
+ });
+ property.constraints.push(constraintArray);
+ }
this.serviceDataType.properties.push(property);
}
);
}
+
+ private getConstraintFormat(constraint: Constraint): any {
+ switch (constraint.type) {
+ case ConstraintTypes.equal:
+ return {
+ [ConstraintTypes.equal]: constraint.value
+ }
+ case ConstraintTypes.less_or_equal:
+ return {
+ [ConstraintTypes.less_or_equal]: constraint.value
+ }
+ case ConstraintTypes.less_than:
+ return {
+ [ConstraintTypes.less_than]: constraint.value
+ }
+ case ConstraintTypes.greater_or_equal:
+ return {
+ [ConstraintTypes.greater_or_equal]: constraint.value
+ }
+ case ConstraintTypes.greater_than:
+ return {
+ [ConstraintTypes.greater_than]: constraint.value
+ }
+ case ConstraintTypes.in_range:
+ return {
+ [ConstraintTypes.in_range]: constraint.value
+ }
+ case ConstraintTypes.length:
+ return {
+ [ConstraintTypes.length]: constraint.value
+ }
+ case ConstraintTypes.max_length:
+ return {
+ [ConstraintTypes.max_length]: constraint.value
+ }
+ case ConstraintTypes.min_length:
+ return {
+ [ConstraintTypes.min_length]: constraint.value
+ }
+ case ConstraintTypes.pattern:
+ return {
+ [ConstraintTypes.pattern]: constraint.value
+ }
+ case ConstraintTypes.valid_values:
+ return {
+ [ConstraintTypes.valid_values]: constraint.value
+ }
+ default:
+ return;
+ }
+ }
+
+ private mapValuesToConstraint(type: string, value: any):Constraint {
+ let constraintType: ConstraintTypes;
+ let constraintValue: any;
+ if (!type) {
+ constraintType = ConstraintTypes.null;
+ constraintValue = "";
+ } else if(type === "valid_values"){
+ constraintType = ConstraintTypes.valid_values;
+ constraintValue = value;
+ } else if(type === "equal") {
+ constraintType = ConstraintTypes.equal;
+ constraintValue = value;
+ } else if(type === "greater_than") {
+ constraintType = ConstraintTypes.greater_than;
+ constraintValue = value;
+ } else if(type === "greater_or_equal") {
+ constraintType = ConstraintTypes.greater_or_equal;
+ constraintValue = value;
+ } else if(type === "less_than") {
+ constraintType = ConstraintTypes.less_than;
+ constraintValue = value;
+ } else if(type === "less_or_equal") {
+ constraintType = ConstraintTypes.less_or_equal;
+ constraintValue = value;
+ } else if(type === "in_range") {
+ constraintType = ConstraintTypes.in_range;
+ constraintValue = value;
+ } else if(type === "range_max_value" || type === "range_min_value") {
+ constraintType = ConstraintTypes.in_range;
+ constraintValue = value;
+ } else if(type === "length") {
+ constraintType = ConstraintTypes.length;
+ constraintValue = value;
+ } else if(type === "min_length") {
+ constraintType = ConstraintTypes.min_length;
+ constraintValue = value;
+ } else if(type === "max_length") {
+ constraintType = ConstraintTypes.max_length;
+ constraintValue = value;
+ } else if(type === "pattern") {
+ constraintType = ConstraintTypes.pattern;
+ constraintValue = value;
+ }
+ return {
+ type:constraintType,
+ value:constraintValue
+ }
+ }
}
\ No newline at end of file
Code Review / sdc.git / commitdiff