Preview an update to a particular {@link Subscription} by it's UUID
<p>
Returns information about a single subscription.

@param uuid UUID of the subscription to preview an update for
@return Subscription the updated subscription preview
190608
public Subscription updateSubscriptionPreview(final String uuid, final SubscriptionUpdate subscriptionUpdate) {
        return doPOST(Subscriptions.SUBSCRIPTIONS_RESOURCE
                      + "/" + uuid + "/preview",
                      subscriptionUpdate,
                      Subscription.class);
    }
885590
@Override
	public void removeByUuid(String uuid) {
		for (CommerceSubscriptionEntry commerceSubscriptionEntry : findByUuid(
				uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(commerceSubscriptionEntry);
		}
	}
171181
@SuppressWarnings("unchecked")
    public <T> T getObjectByUuid(Class<T> clazz, String uuid) {
        return getObjectByUuid(clazz, UUID.fromString(uuid));
    }
709991
public Subscription reactivateSubscription(final Subscription subscription) {
        return doPUT(Subscription.SUBSCRIPTION_RESOURCE + "/" + subscription.getUuid() + "/reactivate",
                     subscription, Subscription.class);
    }
789228
private boolean isUUID(String uuid) {
        try {
            UUID.fromString(uuid);
            return true;
        } catch (Exception ex) {
            return false;
        }
    }
246292
public static ResourceManagerId fromUuidOrNull(@Nullable UUID uuid) {
		return  uuid == null ? null : new ResourceManagerId(uuid);
	}
699262
public UUID toUuid() {
        if (mValue.length != 16) {
            throw new UnsupportedOperationException("Only Identifiers backed by a byte array with length of exactly 16 can be UUIDs.");
        }
        LongBuffer buf = ByteBuffer.wrap(mValue).asLongBuffer();
        return new UUID(buf.get(), buf.get());
    }
1053667
protected Button newSubmitButton(final String id)
	{
		return new Button(id)
		{
			private static final long serialVersionUID = 1L;

			/**
			 * {@inheritDoc}
			 */
			@Override
			public void onSubmit()
			{
				/**
				 * Here comes the action what to do like (i.e. Send Email)
				 */
				onSubmitError(null);
			}
		};
	}
501446
public static UUID getNext(UUID uuid) {
        checkArgument(uuid.version() == 1, "Not a time UUID");
        UUID max = maximumUuid();
        long lsb = uuid.getLeastSignificantBits();
        if (lsb < max.getLeastSignificantBits()) {
            return new UUID(uuid.getMostSignificantBits(), lsb + 1);
        }
        long timestamp = uuid.timestamp();
        if (timestamp < max.timestamp()) {
            return new UUID(getMostSignificantBits(timestamp + 1), minimumUuid().getLeastSignificantBits());
        }
        return null;  // No next exists since uuid == maximumUuid()
    }
76812
public CmsUUID getFormatterId() {

        String value = getStringValue(null);
        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(value)) {
            String[] parts = value.split(SEPARATOR);
            if (parts.length == 2) {
                return new CmsUUID(parts[1]);
            }
        }
        return null;
    }
818914
public URL copyWithService(String serviceUUID) {
        return new URL(this.protocol, this.adapterAddress, this.deviceAddress, this.deviceAttributes,
                serviceUUID, null, null);
    }
558280
public static SQLTable get(final UUID _uuid)
        throws CacheReloadException
    {
        final Cache<UUID, SQLTable> cache = InfinispanCache.get().<UUID, SQLTable>getCache(SQLTable.UUIDCACHE);
        if (!cache.containsKey(_uuid)) {
            SQLTable.getSQLTableFromDB(SQLTable.SQL_UUID, String.valueOf(_uuid));
        }
        return cache.get(_uuid);
    }
742517
public static UUID getPrevious(UUID uuid) {
        checkArgument(uuid.version() == 1, "Not a time UUID");
        UUID min = minimumUuid();
        long lsb = uuid.getLeastSignificantBits();
        if (lsb > min.getLeastSignificantBits()) {
            return new UUID(uuid.getMostSignificantBits(), lsb - 1);
        }
        long timestamp = uuid.timestamp();
        if (timestamp > min.timestamp()) {
            return new UUID(getMostSignificantBits(timestamp - 1), maximumUuid().getLeastSignificantBits());
        }
        return null;  // No previous exists since uuid == minimumUuid()
    }
1352868
@Override
	public com.liferay.commerce.product.model.CPInstance fetchCPInstanceByUuidAndGroupId(
		String uuid, long groupId) {
		return _cpInstanceLocalService.fetchCPInstanceByUuidAndGroupId(uuid,
			groupId);
	}
973434
public Observable<ServiceResponse<List<Export>>> getExportsWithServiceResponseAsync(UUID projectId, UUID iterationId) {
        if (projectId == null) {
            throw new IllegalArgumentException("Parameter projectId is required and cannot be null.");
        }
        if (iterationId == null) {
            throw new IllegalArgumentException("Parameter iterationId is required and cannot be null.");
        }
        if (this.client.apiKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiKey() is required and cannot be null.");
        }
        return service.getExports(projectId, iterationId, this.client.apiKey(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<List<Export>>>>() {
                @Override
                public Observable<ServiceResponse<List<Export>>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<List<Export>> clientResponse = getExportsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
1089986
public Entry getEntryByUUID(final UUID UUID) {
        List<Entry> allEntries = getEntries();

        List<Entry> entries = ListFilter.filter(allEntries, new Filter<Entry>() {

            @Override
            public boolean matches(Entry item) {

                if (item.getUuid() != null && item.getUuid().compareTo(UUID) == 0) {
                    return true;
                } else {
                    return false;
                }
            }
        });

        if (entries.size() == 1) {
            return entries.get(0);
        } else {
            return null;
        }
    }
148720
public FutureData<PushSubscription> update(String id, PushConnector connector, String name) {
        if (id == null || id.isEmpty() || connector == null) {
            throw new IllegalArgumentException("A push subscription ID and output parameters is required");
        }
        FutureData<PushSubscription> future = new FutureData<>();
        URI uri = newParams().forURL(config.newAPIEndpointURI(UPDATE));
        POST request = config.http()
                .POST(uri, new PageReader(newRequestCallback(future, new PushSubscription(), config)))
                .form("id", id);
        for (Map.Entry<String, String> e : connector.parameters().verifyAndGet().entrySet()) {
            request.form(e.getKey(), e.getValue());
        }
        if (name != null && !name.isEmpty()) {
            request.form("name", name);
        }
        performRequest(future, request);
        return future;
    }