org.osgl.storage.ISObject Java Examples

public static boolean isBinary(BeanSpec spec) {
    Class<?> type = spec.rawType();
    if (byte[].class == type) {
        return true;
    }
    if (URL.class == type) {
        return true;
    }
    if (InputStream.class == type) {
        return true;
    }
    if (ISObject.class.isAssignableFrom(type)) {
        return true;
    }
    return false;
}
 

@PostAction
public void upload(ISObject file, StorageServiceManager ssMgr) {
    IStorageService ss = ssMgr.storageService("1128_upload");
    String key = ss.getKey();
    file.getAttribute(ISObject.ATTR_FILE_NAME);
    file = ss.put(key, file);
}
 

private ISObject force() {
    if (null == sobj_) {
        synchronized (this) {
            if (null == sobj_) sobj_ = ss_.get(getKey());
        }
    }
    return sobj_;
}
 

private ISObject _store(FileItemStream fileItemStream) throws IOException {
    String filename = fileItemStream.getName();
    String key = newKey(filename);
    File tmpFile = getFile(key);
    InputStream input = fileItemStream.openStream();
    ThresholdingByteArrayOutputStream output = new ThresholdingByteArrayOutputStream(inMemoryCacheThreshold, tmpFile);
    IO.copy(input, output);

    ISObject retVal;
    if (output.exceedThreshold) {
        retVal = getFull(key);
    } else {
        int size = output.written;
        if (0 == size) {
            return null;
        }
        byte[] buf = output.buf();
        retVal = SObject.of(key, buf, size);
    }

    if (S.notBlank(filename)) {
        retVal.setFilename(filename);
    }
    String contentType = fileItemStream.getContentType();
    if (null != contentType) {
        retVal.setContentType(contentType);
    }
    return retVal;
}
 

public static ISObject store(FileItemStream fileItemStream, App app) {
    UploadFileStorageService ss = app.uploadFileStorageService();
    try {
        return ss._store(fileItemStream);
    } catch (IOException e) {
        throw E.ioException(e);
    }
}
 

@Override
public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
    SerializeWriter out = serializer.out;
    if (object instanceof ISObject) {
        ISObject sobj = (ISObject) object;
        out.write(S.fmt("ISObject[%s]", sobj.getKey()));
        return;
    }
    throw new UnsupportedOperationException("Object type not supported: " + object.getClass());
}
 

public ActionContext addUpload(String name, ISObject sobj) {
    ISObject[] a = uploads.get(name);
    if (null == a) {
        a = new ISObject[1];
        a[0] = sobj;
    } else {
        ISObject[] newA = new ISObject[a.length + 1];
        System.arraycopy(a, 0, newA, 0, a.length);
        newA[a.length] = sobj;
        a = newA;
    }
    uploads.put(name, a);
    return this;
}
 

public ISObject upload(String name) {
    Integer index = attribute(ATTR_CURRENT_FILE_INDEX);
    if (null == index) {
        index = 0;
    }
    return upload(name, index);
}
 

private void registerBuiltInResolvers(AppConfig config) {
// We have the StringValueResolverFinder to handle built in resolver registration
//        put(Date.class, new DateResolver(config));
//        put(LocalDate.class, new JodaLocalDateCodec(config));
//        put(LocalDateTime.class, new JodaLocalDateTimeCodec(config));
//        put(LocalTime.class, new JodaLocalTimeCodec(config));
//        put(DateTime.class, new JodaDateTimeCodec(config));
        // rebind SObjectResolver to ISObject.class in addition to SObject.class
        put(ISObject.class, SObjectResolver.INSTANCE);
    }
 

@Override
public H.Response writeBinary(ISObject binary) {
    byte[] ba = binary.asByteArray();
    ByteBuffer buffer = ByteBuffer.allocateDirect(ba.length);
    buffer.put(ba);
    buffer.flip();
    this.buffer = buffer;
    realResponse.writeContent(buffer);
    this.wroteDirectly = true;
    return this;
}
 

@Override
public List<String> resolve(List<String> bean, String model, ParamValueProvider params) {
    try {
        ISObject sobj = SObjectBinder.INSTANCE.resolve(null, model, params);
        return null == sobj ? fallBack(model, params) : IO.readLines(sobj.asInputStream());
    } catch (Exception e) {
        return fallBack(model, params);
    }
}
 

@Override
public UndertowResponse writeBinary(ISObject binary) {
    beforeWritingContent();
    File file = tryGetFileFrom(binary);
    if (null != file) {
        return send(file);
    }
    byte[] ba = binary.asByteArray();
    ByteBuffer buffer = ByteBuffer.wrap(ba);
    sender().send(buffer);
    endAsync = !blocking();
    afterWritingContent();
    return this;
}
 

@Override
public String resolve(String value) {
    try {
        ISObject sobj = SObjectResolver.INSTANCE.resolve(value);
        return null == sobj ? fallBack(value) : IO.readContentAsString(sobj.asInputStream());
    } catch (Exception e) {
        return fallBack(value);
    }
}
 

private File tryGetFileFrom(ISObject sobj) {
    String className = sobj.getClass().getSimpleName();
    if (className.contains("FileSObject")) {
        return sobj.asFile();
    }
    return null;
}
 

@Override
public List<String> resolve(String value) {
    try {
        ISObject sobj = SObjectResolver.INSTANCE.resolve(value);
        return null == sobj ? fallBack(value) : IO.readLines(sobj.asInputStream());
    } catch (Exception e) {
        return fallBack(value);
    }
}
 

@Override
public String resolve(String bean, String model, ParamValueProvider params) {
    try {
        ISObject sobj = SObjectBinder.INSTANCE.resolve(null, model, params);
        return null == sobj ? fallBack(model, params) : IO.readContentAsString(sobj.asInputStream());
    } catch (Exception e) {
        return fallBack(model, params);
    }
}
 

@Override
public File resolve(File file, String s, ParamValueProvider paramValueProvider) {
    ActionContext ctx = $.cast(paramValueProvider);
    if (ctx.req().url().startsWith("/~/cmd/run")) {
        String fileName = ctx.paramVal(s);
        if (S.isBlank(fileName)) {
            return null;
        }
        return new File(fileName);
    }
    ISObject sobj = ctx.upload(s);
    return null == sobj ? null : sobj.asFile();
}
 

public ISObject toSObject() {
    return SObject.of(toInputStream());
}
 

@PostAction
public boolean handleUpload(ISObject file, String fileName) {
    return null == file;
}
 

private <T> T _to(Type type) {
    Object o;
    InputStreamHandlerDispatcher inputStreamHandler = null;
    MimeType mimeType = this.mimeType;
    if (null == mimeType) {
        String sourceName = sourceName();
        if (null != sourceName) {
            String suffix = S.fileExtension(sourceName);
            mimeType = MimeType.findByFileExtension(suffix);
        }
    }
    if (null != mimeType) {
        inputStreamHandler = inputStreamHandlerLookup.get(mimeType);
    }
    if (String.class == type) {
        o = toString();
    } else if (TypeReference.LIST_STRING == type) {
        if (null != inputStreamHandler && inputStreamHandler.support(type)) {
            return inputStreamHandler.read(toInputStream(), type, mimeType, hint);
        }
        o = toLines();
    } else if (InputStream.class == type) {
        o = toInputStream();
    } else if (Reader.class == type) {
        o = toReader();
    } else if (ISObject.class == type || SObject.class == type) {
        o = toSObject();
    } else if (Properties.class == type) {
        if (null != inputStreamHandler && inputStreamHandler.support(type)) {
            return inputStreamHandler.read(toInputStream(), type, mimeType, hint);
        }
        o = toProperties();
    } else if (byte[].class == type) {
        o = toByteArray();
    } else {
        if (null != inputStreamHandler) {
            return inputStreamHandler.read(toInputStream(), type, mimeType, hint);
        }
        o = toUnknownType(type);
    }
    return $.cast(o);
}
 

@Override
public ISObject toSObject() {
    return SObject.of(source.toString());
}
 

public SObjectReadStage(ISObject isObject) {
    super(isObject);
    sourceName = isObject.getFilename();
}
 

public static SObjectWriteStage write(ISObject sobj) {
    return new SObjectWriteStage(sobj);
}
 

public static SObjectReadStage read(ISObject sobj) {
    return new SObjectReadStage(sobj);
}
 

@Override
public ISObject setAttribute(String key, String val) {
    assertValid();
    attrs.put(key, val);
    return this;
}
 

@Override
public ISObject setAttributes(Map<String, String> attrs) {
    assertValid();
    setAttrs(attrs);
    return this;
}
 

public static SObject valueOf(String key, ISObject copy) {
    SObject sobj = of(key, copy.asByteArray());
    sobj.setAttrs(copy.getAttributes());
    return sobj;
}
 

protected SObjectWriteStage(ISObject isObject) {
    super(isObject);
}
 

public ReqBuilder post(ISObject content) {
    this.post();
    this.postAttachment = content;
    return this;
}
 

@Override
public ISObject resolve(ISObject sobj, String s, ParamValueProvider paramValueProvider) {
    E.illegalArgumentIf(!(paramValueProvider instanceof ActionContext));
    return SObjectResolver.INSTANCE.resolve(s);
}