public ResourceOwnerContext(final EntityMetadataMessage message) { entityId = message.getEntity(); token = message.getToken(); tenantId = message.getTenantId(); entityMetadata = message; }
public AlarmSubscription(final String sourceEntityId, final String targetEntityId, final String alertId, final NotificationParams notificationParams) { super(sourceEntityId, targetEntityId, SubscribeType.ALARM); this.alertId = alertId; setNotificationParams(notificationParams); }
public DataSubscription(final String entityId, final String providerId, final NotificationParams notificationParams) { super(entityId, providerId, SubscribeType.DATA); this.providerId = providerId; setNotificationParams(notificationParams); }
private SubscriptionMessage parseSubscriptionToSubscribeMessage(final Subscription subscription) { final SubscriptionMessage message = new SubscriptionMessage(); message.setType(subscription.getType().toString()); if (subscription.getNotificationParams() != null) { message.setEndpoint(subscription.getNotificationParams().getEndpoint()); message.setMaxRetries(subscription.getNotificationParams().getMaxRetries()); message.setRetryDelay(subscription.getNotificationParams().getRetryDelay()); } switch (subscription.getType()) { case DATA: message.setProvider(((DataSubscription) subscription).getProviderId()); message.setSensor(((DataSubscription) subscription).getSensorId()); break; case ALARM: message.setAlert(((AlarmSubscription) subscription).getAlertId()); break; case ORDER: message.setProvider(((OrderSubscription) subscription).getOwnerEntityId()); message.setSensor(((OrderSubscription) subscription).getSensorId()); break; } return message; }
public static Topic getChannel(final Subscription subscription) { Assert.notNull(subscription); switch (subscription.getType()) { case DATA: return buildTopic(PubSubChannelPrefix.data, ((DataSubscription) subscription).getProviderId(), ((DataSubscription) subscription).getSensorId()); case ORDER: return buildTopic(PubSubChannelPrefix.order, ((OrderSubscription) subscription).getOwnerEntityId(), ((OrderSubscription) subscription).getSensorId()); case ALARM: return buildTopic(PubSubChannelPrefix.alarm, ((AlarmSubscription) subscription).getAlertId()); default: throw new IllegalArgumentException("Unknown subscription type:" + subscription.getType()); } }
@Override public void validateRequestMessageOnPut(final SubscribeInputMessage requestMessage) throws MessageValidationException { Assert.notNull(requestMessage); Assert.notNull(requestMessage.getSubscription()); final Subscription subscription = requestMessage.getSubscription(); if (subscription.getType() == null) { throw new MessageValidationException("To register a subscription is mandatory to fill in the type of the subscription"); } if (subscription.getNotificationParams() == null || !StringUtils.hasText(subscription.getNotificationParams().getEndpoint())) { throw new MessageValidationException("To register a subscription is mandatory to fill in the endpoint of the subscription"); } super.validateRequestMessageOnPut(requestMessage); } }
@Override public void validateRequestMessageOnPut(final DataInputMessage requestMessage) throws MessageValidationException { Assert.notNull(requestMessage); if (CollectionUtils.isEmpty(requestMessage.getObservations())) { throw new MessageValidationException("To publish data is mandatory to fill in the observations field"); } for (final Observation observation : requestMessage.getObservations()) { if (observation.getValue() == null) { throw new MessageValidationException("To publish data is mandatory to fill in the value field"); } } super.validateRequestMessageOnPut(requestMessage); }
private void registerProviderAndSensorIfNeedBe(final Observation data) { // Save both the provider and the sensor in Redis only if rejectUnknownSensors is false. By // default, sensor state is marked as ghost if (!rejectUnknownSensors) { resourceService.registerProviderIfNeedBe(data.getProvider()); resourceService.registerSensorIfNeedBe(data.getProvider(), data.getSensor(), SensorState.ghost, false); } }
@Override public void validateRequestMessageOnGet(final AdminInputMessage requestMessage) throws MessageValidationException { Assert.notNull(requestMessage); if (AdminType.subscriptions.equals(requestMessage.getType()) && !StringUtils.hasText(requestMessage.getEntity())) { throw new MessageValidationException("To get subscriptions from an entity is mandatory to inform the entity"); } super.validateRequestMessageOnGet(requestMessage); } }
private OrderMessage parseOrderToOrderMessage(final Order order) { final OrderMessage message = new OrderMessage(); message.setOrder(order.getMessage()); message.setSender(order.getSender()); message.setTimestamp(timestampToString(order.getTimestamp())); message.setTime(order.getTimestamp()); return message; }
public AdminInputMessage(final AdminType type) { this(); setType(type); }
@Override public List<Subscription> getSubscriptions(final String entityId) { final Subscription subscription = new Subscription(entityId); return subscribeService.get(subscription); }
private Subscription buildAlarmSubscription(final SentiloRequest request, final NotificationParams notificationParams) { final String entityId = request.getEntitySource(); final String alertId = request.getResourcePart(1); // The request doesn't identify who is the alert owner. It is filled in in a subsequent // step return new AlarmSubscription(entityId, null, alertId, notificationParams); }
private Subscription buildOrderSubscription(final SentiloRequest request, final NotificationParams notificationParams) { final String entityId = request.getEntitySource(); final String providerId = request.getResourcePart(1); final String sensorId = request.getResourcePart(2); return new OrderSubscription(entityId, providerId, sensorId, notificationParams); }
public OrderSubscription(final String sourceEntityId, final String providerId, final NotificationParams notificationParams) { super(sourceEntityId, providerId, SubscribeType.ORDER); setNotificationParams(notificationParams); }
public PermissionType getType() { return PermissionType.valueOf(type); }
@Override public String getTenantOwner(final String entity) { return idEntitiesMetadataMap.containsKey(entity) ? idEntitiesMetadataMap.get(entity).getTenantId() : null; }
private void checkTargetResourceState(final Subscription subscription) { Assert.notNull(subscription); switch (subscription.getType()) { case DATA: checkSensorState(((DataSubscription) subscription).getProviderId(), ((DataSubscription) subscription).getSensorId()); break; case ORDER: checkSensorState(((OrderSubscription) subscription).getOwnerEntityId(), ((OrderSubscription) subscription).getSensorId()); break; case ALARM: checkAlertState(((AlarmSubscription) subscription).getAlertId()); break; default: throw new IllegalArgumentException("Unknown subscription type:" + subscription.getType()); } }
public RequesterContext(final EntityMetadataMessage message) { this(message.getEntity()); entityMetadata = message; token = message.getToken(); tenantId = message.getTenantId(); }
public AdminInputMessage parsePostPutRequest(final SentiloRequest request) throws PlatformException { final AdminType type = getAdminType(request); final AdminInputMessage inputMessage = (AdminInputMessage) readInternal(AdminInputMessage.class, request); inputMessage.setType(type); return inputMessage; }