示例#1
0
  @RequestMapping(value = "/events/{eventName}/pending-payments/bulk-confirmation", method = POST)
  public List<Triple<Boolean, String, String>> bulkConfirmation(
      @PathVariable("eventName") String eventName,
      Principal principal,
      @RequestBody UploadBase64FileModification file)
      throws IOException {

    try (InputStreamReader isr = new InputStreamReader(file.getInputStream());
        CSVReader reader = new CSVReader(isr)) {
      Event event = loadEvent(eventName, principal);
      return reader
          .readAll()
          .stream()
          .map(
              line -> {
                String reservationID = null;
                try {
                  Validate.isTrue(line.length >= 2);
                  reservationID = line[0];
                  ticketReservationManager.validateAndConfirmOfflinePayment(
                      reservationID, event, new BigDecimal(line[1]));
                  return Triple.of(Boolean.TRUE, reservationID, "");
                } catch (Exception e) {
                  return Triple.of(
                      Boolean.FALSE, Optional.ofNullable(reservationID).orElse(""), e.getMessage());
                }
              })
          .collect(Collectors.toList());
    }
  }
示例#2
0
 private Triple<Integer, Integer, Float> anim() throws IOException {
   chunk("ANIM");
   int flags = buf.getInt();
   int frames = buf.getInt();
   float fps = buf.getFloat();
   dump("ANIM(" + flags + ", " + frames + ", " + fps + ")");
   popLimit();
   return Triple.of(flags, frames, fps);
 }
 /**
  * Returns a memoized (caching) version of this {@link ObjBiByteToCharFunction}. Whenever it is
  * called, the mapping between the input parameters and the return value is preserved in a cache,
  * making subsequent calls returning the memoized value instead of computing the return value
  * again.
  *
  * <p>Unless the function and therefore the used cache will be garbage-collected, it will keep all
  * memoized values forever.
  *
  * @return A memoized (caching) version of this {@code ObjBiByteToCharFunction}.
  * @implSpec This implementation does not allow the input parameters or return value to be {@code
  *     null} for the resulting memoized function, as the cache used internally does not permit
  *     {@code null} keys or values.
  * @implNote The returned memoized function can be safely used concurrently from multiple threads
  *     which makes it thread-safe.
  */
 @Nonnull
 default ObjBiByteToCharFunction<T> memoized() {
   if (isMemoized()) {
     return this;
   } else {
     final Map<Triple<T, Byte, Byte>, Character> cache = new ConcurrentHashMap<>();
     final Object lock = new Object();
     return (ObjBiByteToCharFunction<T> & Memoized)
         (t, value1, value2) -> {
           final char returnValue;
           synchronized (lock) {
             returnValue =
                 cache.computeIfAbsent(
                     Triple.of(t, value1, value2),
                     key -> applyAsChar(key.getLeft(), key.getMiddle(), key.getRight()));
           }
           return returnValue;
         };
   }
 }
 /**
  * Returns a memoized (caching) version of this {@link ThrowableObjBiBooleanToByteFunction}.
  * Whenever it is called, the mapping between the input parameters and the return value is
  * preserved in a cache, making subsequent calls returning the memoized value instead of computing
  * the return value again.
  *
  * <p>Unless the function and therefore the used cache will be garbage-collected, it will keep all
  * memoized values forever.
  *
  * @return A memoized (caching) version of this {@code ThrowableObjBiBooleanToByteFunction}.
  * @implSpec This implementation does not allow the input parameters or return value to be {@code
  *     null} for the resulting memoized function, as the cache used internally does not permit
  *     {@code null} keys or values.
  * @implNote The returned memoized function can be safely used concurrently from multiple threads
  *     which makes it thread-safe.
  */
 @Nonnull
 default ThrowableObjBiBooleanToByteFunction<T, X> memoized() {
   if (isMemoized()) {
     return this;
   } else {
     final Map<Triple<T, Boolean, Boolean>, Byte> cache = new ConcurrentHashMap<>();
     final Object lock = new Object();
     return (ThrowableObjBiBooleanToByteFunction<T, X> & Memoized)
         (t, value1, value2) -> {
           final byte returnValue;
           synchronized (lock) {
             returnValue =
                 cache.computeIfAbsent(
                     Triple.of(t, value1, value2),
                     ThrowableFunction.of(
                         key ->
                             applyAsByteThrows(key.getLeft(), key.getMiddle(), key.getRight())));
           }
           return returnValue;
         };
   }
 }
 /**
  * Returns a memoized (caching) version of this {@link ThrowableTriByteToFloatFunction}. Whenever
  * it is called, the mapping between the input parameters and the return value is preserved in a
  * cache, making subsequent calls returning the memoized value instead of computing the return
  * value again.
  *
  * <p>Unless the function and therefore the used cache will be garbage-collected, it will keep all
  * memoized values forever.
  *
  * @return A memoized (caching) version of this {@code ThrowableTriByteToFloatFunction}.
  * @implSpec This implementation does not allow the input parameters or return value to be {@code
  *     null} for the resulting memoized function, as the cache used internally does not permit
  *     {@code null} keys or values.
  * @implNote The returned memoized function can be safely used concurrently from multiple threads
  *     which makes it thread-safe.
  */
 @Nonnull
 default ThrowableTriByteToFloatFunction<X> memoized() {
   if (isMemoized()) {
     return this;
   } else {
     final Map<Triple<Byte, Byte, Byte>, Float> cache = new ConcurrentHashMap<>();
     final Object lock = new Object();
     return (ThrowableTriByteToFloatFunction<X> & Memoized)
         (value1, value2, value3) -> {
           final float returnValue;
           synchronized (lock) {
             returnValue =
                 cache.computeIfAbsent(
                     Triple.of(value1, value2, value3),
                     ThrowableFunction.of(
                         key ->
                             applyAsFloatThrows(key.getLeft(), key.getMiddle(), key.getRight())));
           }
           return returnValue;
         };
   }
 }
示例#6
0
  @Override
  public ListenableFuture<Triple<byte[], byte[], String>> encryptAsync(
      final byte[] plaintext,
      final byte[] iv,
      final byte[] authenticationData,
      final String algorithm)
      throws NoSuchAlgorithmException {

    if (plaintext == null) {
      throw new IllegalArgumentException("plaintext");
    }

    // Interpret the requested algorithm
    String algorithmName =
        (Strings.isNullOrWhiteSpace(algorithm) ? getDefaultEncryptionAlgorithm() : algorithm);
    Algorithm baseAlgorithm = AlgorithmResolver.Default.get(algorithmName);

    if (baseAlgorithm == null || !(baseAlgorithm instanceof AsymmetricEncryptionAlgorithm)) {
      throw new NoSuchAlgorithmException(algorithmName);
    }

    AsymmetricEncryptionAlgorithm algo = (AsymmetricEncryptionAlgorithm) baseAlgorithm;

    ICryptoTransform transform;
    ListenableFuture<Triple<byte[], byte[], String>> result;

    try {
      transform = algo.CreateEncryptor(_keyPair, _provider);
      result =
          Futures.immediateFuture(
              Triple.of(transform.doFinal(plaintext), (byte[]) null, algorithmName));
    } catch (Exception e) {
      result = Futures.immediateFailedFuture(e);
    }

    return result;
  }