private boolean showMessageDataType(final TypedMessage message) { return ((message.getActualType() != null) && (message.getResourceType() == null)); }
private boolean hasOverridedMediaTypes(final TypedMessage message) { boolean _isEmpty = message.getMediaTypes().isEmpty(); boolean _not = (!_isEmpty); if (_not) { EObject _eContainer = message.eContainer(); boolean _elementsEqual = IterableExtensions.elementsEqual(message.getMediaTypes(), ((Method) _eContainer).getContainingResourceDefinition().getMediaTypes()); return (!_elementsEqual); } return false; }
private MessageRealizationContext(final TypedMessage message) { Structure _dataType = message.getDataType(); boolean _tripleEquals = (_dataType == null); if (_tripleEquals) { throw new IllegalArgumentException("Only a type-bound message may be used as a realization context"); } this.message = message; }
private Structure getContainingResourceDataType(final TypedMessage msg) { Structure _xifexpression = null; boolean _isUseParentTypeReference = msg.isUseParentTypeReference(); if (_isUseParentTypeReference) { EObject _eContainer = msg.eContainer(); _xifexpression = this.getResourceDataType(((Method) _eContainer).getContainingResourceDefinition()); } return _xifexpression; }
@Check public void checkTypedMessageBody(TypedMessage message) { if (message.getActualType() == null) { if (message.getInlineObjectRealization() != null) { error(Messages.XtextDslJavaValidator_typedMessageBody, message, RapidmlPackage.Literals.REALIZATION_CONTAINER__PROPERTIES); } if (!message.getReferenceTreatments().isEmpty()) { error(Messages.XtextDslJavaValidator_typedMessageBody, message, RapidmlPackage.Literals.REALIZATION_CONTAINER__REFERENCE_TREATMENTS); } } }
@Check public void checkTypedMessageUsingThisKeyword(TypedMessage message) { if (message.isUseParentTypeReference()) { if (message.getDataType() != null) { error(Messages.XtextDslJavaValidator_typedMessageThisNotAllowedOnType, message, RapidmlPackage.Literals.REALIZATION_CONTAINER__DATA_TYPE); if (message.getInlineObjectRealization() != null || !message.getReferenceTreatments().isEmpty()) { error(Messages.XtextDslJavaValidator_typedMessagePropertySetNotAllowed, message, feature); } else { ResourceDefinition resourceDefinition = ((Method) message.eContainer()) .getContainingResourceDefinition(); ServiceDataResource dataResource = (ServiceDataResource) resourceDefinition; final String actualTypeName = message.getResourceType().getName(); final String expectedTypeName = dataResource.getName();
protected void processMessage(TypedMessage message) { if (message.getActualType() == null) { // no realization processing required for a dataless message return; } maybeSetWithDefaultRealization(message); if (message.getResourceType() instanceof ServiceDataResource // instanceof also checks for non-null && ((ServiceDataResource) message.getResourceType()).isWithDefaultRealization()) { message.setWithDefaultRealization(true); message.setEffectiveRealization( ((ServiceDataResource) message.getResourceType()).getEffectiveRealization()); } if (message.getResourceType() != null) { // should re-use realization of the resource return; } if (message.isWithDefaultRealization()) { RealizationRule rule = autoRealizationProcessor.processMessage(message); if (rule != null) { storeAutoRealization(message).accept(rule); } } if (message.getActualType() != null) { referenceTreatmentNormalizer.normalizeUserDefinedReferenceTreatments(message, message.getActualType()); } processNestedReferenceTreatments(message, message); }
/** * Returns true if the given message has a resource type else false. * * @param message {@link com.modelsolv.reprezen.restapi.TypedMessage} to check * @return Boolean */ public Boolean hasResourceType(TypedMessage message) { return message.getResourceType() != null; }
@Override public Structure getStructure() { return this.message.getActualType(); }
protected String getMessageType(final TypedMessage message, final Class<?> defaultValue, final String nullValue) { if ((message == null)) { return nullValue; } EObject _xifexpression = null; ResourceDefinition _resourceType = message.getResourceType(); boolean _tripleNotEquals = (_resourceType != null); if (_tripleNotEquals) { _xifexpression = message.getResourceType(); } else { _xifexpression = message.getDataType(); } final Object zenMessageType = _xifexpression; if ((zenMessageType != null)) { boolean _containsRow = this.zenElement2ClassQName.containsRow(zenMessageType); boolean _not = (!_containsRow); if (_not) { return this.getTypeName(defaultValue); } final String className = this.zenElement2ClassQName.get(zenMessageType, "jaxbClassName"); String _get = this.zenElement2ClassQName.get(zenMessageType, "jaxbPackageName"); String _plus = (_get + "."); String _plus_1 = (_plus + className); this.addImport(_plus_1); return className; } return this.getTypeName(defaultValue); }
/** * @deprecated use {@link CommonServices#getRequestTypeName(TypedRequest)} or * {@link CommonServices#getResponseTypeName(TypedResponse)} instead * @param message typed message * @return generated type name for XSD generator that avoid name clashes */ @Deprecated public static String getMessageTypeName(TypedMessage message) { Method method = (Method) message.eContainer(); String methodName = method.getHttpMethod().getName().toLowerCase() + method.getContainingResourceDefinition().getName(); final Structure type = message.getActualType(); ImmutableList<TypedMessage> list = ImmutableList.copyOf(Iterators.filter( Iterators.filter(method.getContainingResourceDefinition().eAllContents(), TypedMessage.class), new Predicate<TypedMessage>() { @Override public boolean apply(TypedMessage input) { return input.getActualType() == type; } })); String baseName = Strings.toFirstUpper(methodName) + '_' + message.getActualType().getName(); if (list.size() > 1) { return baseName + '_' + (list.indexOf(message) + 1); } return baseName; }
private CharSequence generateMessageDataType(final TypedMessage message) { StringConcatenation _builder = new StringConcatenation(); if (((!message.getReferenceTreatments().isEmpty()) || (!IterableExtensions.isEmpty(IterableExtensions.<Feature>filter(message.getActualType().getOwnedFeatures(), ((Function1<Feature, Boolean>) (Feature e) -> { return Boolean.valueOf(((!this.hasReferenceTreatment(message, e)) && message.isIncluded(e))); })))))) { _builder.append("<h4>Data Properties</h4>"); return Boolean.valueOf((!_hasReferenceTreatment)); }; Iterable<Feature> _filter = IterableExtensions.<Feature>filter(message.getActualType().getOwnedFeatures(), _function); for(final Feature aFeature : _filter) { boolean _isIncluded = message.isIncluded(aFeature); if (_isIncluded) { CharSequence _generateIncludedPropertyRow = this.generateIncludedPropertyRow(this.getIncludedProperty(message, aFeature));
private CharSequence generateRepresentationParameters(final TypedMessage message, final MediaType mediaType, final ServiceDataResource containingDataResource) { CharSequence _xifexpression = null; ResourceDefinition _resourceType = message.getResourceType(); boolean _tripleEquals = (_resourceType == null); if (_tripleEquals) { StringConcatenation _builder = new StringConcatenation(); { Iterable<ReferenceLink> _filter = Iterables.<ReferenceLink>filter(message.getReferenceTreatments(), ReferenceLink.class); for(final ReferenceLink referenceLink : _filter) { CharSequence _generateRepresentationParameter = this.generateRepresentationParameter(referenceLink, mediaType, this._wadlHelper.getMessageTypeName(message), containingDataResource); _builder.append(_generateRepresentationParameter); _builder.newLineIfNotEmpty(); } } _xifexpression = _builder; } else { StringConcatenation _builder_1 = new StringConcatenation(); CharSequence _generateRepresentationParameters = this.generateRepresentationParameters(this._wadlHelper.<ResourceDefinition>getEContainer(message, ResourceDefinition.class), mediaType); _builder_1.append(_generateRepresentationParameters); _xifexpression = _builder_1; } return _xifexpression; }
public static EList<Example> getAllExamples(TypedMessage message) { if (!message.getExamples().isEmpty()) { return message.getExamples(); } ResourceDefinition resource = message.getResourceType(); if (resource != null) { EList<Example> resourceExamples = resource.getExamples(); if (!resourceExamples.isEmpty()) { return resourceExamples; } if (resource instanceof ServiceDataResource) { Structure dataType = ((ServiceDataResource) resource).getDataType(); List<Example> result = new ArrayList<Example>(dataType.getDataExamples().size()); for (DataExample dataExample : dataType.getDataExamples()) { result.add(toExample(dataExample)); } return ECollections.asEList(result); } } return ECollections.emptyEList(); }
public static Optional<ServiceDataResource> getContainingResourceDefinition(TypedMessage message) { Method method = (Method) message.eContainer(); if (method != null && method.getContainingResourceDefinition() instanceof ServiceDataResource) { return Optional.of((ServiceDataResource)method.getContainingResourceDefinition()); } return Optional.empty(); }
private CharSequence generateReferenceTreatments(final TypedMessage message) { StringConcatenation _builder = new StringConcatenation(); { EList<ReferenceTreatment> _referenceTreatments = message.getReferenceTreatments(); for(final ReferenceTreatment refTreatment : _referenceTreatments) { EList<PropertyRealization> _includedProperties = message.getIncludedProperties(); CycleDetector<ReferenceTreatment> _cycleDetector = new CycleDetector<ReferenceTreatment>(); String _generateReferenceTreatment = this.generateReferenceTreatment(refTreatment, _includedProperties, _cycleDetector, Integer.valueOf(0)); _builder.append(_generateReferenceTreatment); _builder.newLineIfNotEmpty(); } } return _builder; }
private boolean hasReferenceTreatment(final TypedMessage message, final Feature feature) { final Function1<ReferenceTreatment, ReferenceElement> _function = (ReferenceTreatment it) -> { return it.getReferenceElement(); }; final Function1<ReferenceElement, Boolean> _function_1 = (ReferenceElement f) -> { return Boolean.valueOf((f == feature)); }; return IterableExtensions.<ReferenceElement>exists(ListExtensions.<ReferenceTreatment, ReferenceElement>map(message.getReferenceTreatments(), _function), _function_1); }
public void process(TypedMessage message) { // add resource level media types if message mediaTypes are absent if (message.getMediaTypes().isEmpty()) { Optional<ServiceDataResource> resource = getContainingResourceDefinition(message); if (resource.isPresent()) { message.getMediaTypes().addAll(resource.get().getMediaTypes()); } } }
public List<Constraint> getMessageParameterConstraints(final MessageParameter parameter) { final SourceReference ref = parameter.getSourceReference(); boolean _matched = false; if (ref instanceof PropertyReference) { _matched=true; final Function1<PropertyRealization, Boolean> _function = (PropertyRealization it) -> { Feature _baseProperty = it.getBaseProperty(); PrimitiveProperty _conceptualFeature = ((PropertyReference)ref).getConceptualFeature(); return Boolean.valueOf(Objects.equal(_baseProperty, _conceptualFeature)); }; PropertyRealization property = IterableExtensions.<PropertyRealization>findFirst(parameter.getContainingMessage().getIncludedProperties(), _function); if ((property == null)) { return ((PropertyReference)ref).getConceptualFeature().getAllConstraints(); } return property.getAllConstraints(); } return null; }
private boolean hasResourceType(final TypedMessage message) { ResourceDefinition _resourceType = message.getResourceType(); return (_resourceType != null); }