add sdk

sdk/src/main/java/cn/wildfirechat/sdk/ChatAdmin.java

@@ -0,0 +1,25 @@
+package cn.wildfirechat.sdk;
+
+import cn.wildfirechat.sdk.model.*;
+
+public class ChatAdmin {
+    public static void init(String url, String secret) {
+        HttpUtils.init(url, secret);
+    }
+
+    public static IMResult<User> getUserByName(String mobile) throws Exception {
+        String path = "/admin/user/info";
+        UserName name = new UserName(mobile);
+        return HttpUtils.httpJsonPost(path, name, User.class);
+    }
+
+    public static IMResult<UserId> createUser(User user) throws Exception {
+        String path = "/admin/user/create";
+        return HttpUtils.httpJsonPost(path, user, UserId.class);
+    }
+
+    public static IMResult<Token> getUserToken(String userId, String clientId) throws Exception {
+        String path = "/admin/user/token";
+        return HttpUtils.httpJsonPost(path, new GetTokenRequest(userId, clientId), Token.class);
+    }
+}

sdk/src/main/java/cn/wildfirechat/sdk/HttpUtils.java

@@ -0,0 +1,109 @@
+package cn.wildfirechat.sdk;
+
+import cn.wildfirechat.sdk.model.IMResult;
+import com.google.gson.Gson;
+import ikidou.reflect.TypeBuilder;
+import org.apache.commons.codec.digest.DigestUtils;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpStatus;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.lang.reflect.Type;
+import java.nio.charset.Charset;
+
+
+public class HttpUtils {
+    private static final Logger LOG = LoggerFactory.getLogger(HttpUtils.class);
+
+    private static String adminUrl;
+    private static String adminSecret;
+
+    static void init(String url, String secret) {
+        adminUrl = url;
+        adminSecret = secret;
+    }
+
+    static <T> IMResult<T> httpJsonPost(String path, Object object, Class<T> clazz) throws Exception{
+        if (isNullOrEmpty(adminUrl) || isNullOrEmpty(path)) {
+            LOG.error("Not init IM SDK correctly. Do you forget init it?");
+            throw new Exception("SDK url or secret lack!");
+        }
+
+        String url = adminUrl + path;
+        HttpPost post = null;
+        try {
+            HttpClient httpClient = HttpClientBuilder.create().build();
+
+            int nonce = (int)(Math.random() * 100000 + 3);
+            long timestamp = System.currentTimeMillis();
+            String str = nonce + "|" + adminSecret + "|" + timestamp;
+            String sign = DigestUtils.sha1Hex(str);
+
+
+            post = new HttpPost(url);
+            post.setHeader("Content-type", "application/json; charset=utf-8");
+            post.setHeader("Connection", "Keep-Alive");
+            post.setHeader("nonce", nonce + "");
+            post.setHeader("timestamp", "" + timestamp);
+            post.setHeader("sign", sign);
+
+            String jsonStr = new Gson().toJson(object);
+            LOG.info("http request content: {}", jsonStr);
+
+            StringEntity entity = new StringEntity(jsonStr, Charset.forName("UTF-8"));
+            entity.setContentEncoding("UTF-8");
+            entity.setContentType("application/json");
+            post.setEntity(entity);
+            HttpResponse response = httpClient.execute(post);
+
+            int statusCode = response.getStatusLine().getStatusCode();
+            if(statusCode != HttpStatus.SC_OK){
+                LOG.info("Request error: "+statusCode);
+                throw new Exception("Http request error with code:" + statusCode);
+            }else{
+                BufferedReader in = new BufferedReader(new InputStreamReader(response.getEntity()
+                    .getContent(),"utf-8"));
+                StringBuffer sb = new StringBuffer();
+                String line;
+                String NL = System.getProperty("line.separator");
+                while ((line = in.readLine()) != null) {
+                    sb.append(line + NL);
+                }
+
+                in.close();
+
+                String content = sb.toString();
+                LOG.info("http request response content: {}", content);
+
+                return fromJsonObject(content, clazz);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw e;
+        }finally{
+            if(post != null){
+                post.releaseConnection();
+            }
+        }
+    }
+
+    private static <T> IMResult<T> fromJsonObject(String content, Class<T> clazz) {
+        Type type = TypeBuilder
+                .newInstance(IMResult.class)
+                .addTypeParam(clazz)
+                .build();
+        return new Gson().fromJson(content, type);
+    }
+
+    private static boolean isNullOrEmpty(String str) {
+        return str == null || str.isEmpty();
+    }
+
+}

sdk/src/main/java/cn/wildfirechat/sdk/model/GetTokenRequest.java

@@ -0,0 +1,27 @@
+package cn.wildfirechat.sdk.model;
+
+public class GetTokenRequest {
+    private String userId;
+    private String clientId;
+
+    public GetTokenRequest(String userId, String clientId) {
+        this.userId = userId;
+        this.clientId = clientId;
+    }
+
+    public String getClientId() {
+        return clientId;
+    }
+
+    public void setClientId(String clientId) {
+        this.clientId = clientId;
+    }
+
+    public String getUserId() {
+        return userId;
+    }
+
+    public void setUserId(String userId) {
+        this.userId = userId;
+    }
+}

sdk/src/main/java/cn/wildfirechat/sdk/model/IMResult.java

@@ -0,0 +1,38 @@
+package cn.wildfirechat.sdk.model;
+
+import common.cn.wildfirechat.ErrorCode;
+
+public class IMResult<T> {
+
+    public int code;
+    public String msg;
+    public T result;
+
+    public int getCode() {
+        return code;
+    }
+
+    public void setCode(int code) {
+        this.code = code;
+    }
+
+    public ErrorCode getErrorCode() {
+        return ErrorCode.fromCode(code);
+    }
+
+    public String getMsg() {
+        return msg;
+    }
+
+    public void setMsg(String msg) {
+        this.msg = msg;
+    }
+
+    public T getResult() {
+        return result;
+    }
+
+    public void setResult(T result) {
+        this.result = result;
+    }
+}

sdk/src/main/java/cn/wildfirechat/sdk/model/SendMessageResult.java

@@ -0,0 +1,30 @@
+package cn.wildfirechat.sdk.model;
+
+public class SendMessageResult {
+    private long messageUid;
+    private long timestamp;
+
+    public SendMessageResult() {
+    }
+
+    public SendMessageResult(long messageUid, long timestamp) {
+        this.messageUid = messageUid;
+        this.timestamp = timestamp;
+    }
+
+    public long getMessageUid() {
+        return messageUid;
+    }
+
+    public void setMessageUid(long messageUid) {
+        this.messageUid = messageUid;
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public void setTimestamp(long timestamp) {
+        this.timestamp = timestamp;
+    }
+}

sdk/src/main/java/cn/wildfirechat/sdk/model/Token.java

@@ -0,0 +1,22 @@
+package cn.wildfirechat.sdk.model;
+
+public class Token {
+    private String token;
+    private String userId;
+
+    public String getToken() {
+        return token;
+    }
+
+    public void setToken(String token) {
+        this.token = token;
+    }
+
+    public String getUserId() {
+        return userId;
+    }
+
+    public void setUserId(String userId) {
+        this.userId = userId;
+    }
+}

sdk/src/main/java/cn/wildfirechat/sdk/model/User.java

@@ -0,0 +1,121 @@
+package cn.wildfirechat.sdk.model;
+
+public class User {
+    private String userId;
+    private String name;
+    private String password;
+    private String displayName;
+    private String portrait;
+    private int gender;
+    private String mobile;
+    private String email;
+    private String address;
+    private String company;
+    private String social;
+    private String extra;
+    private long updateDt;
+
+    public String getSocial() {
+        return social;
+    }
+
+    public void setSocial(String social) {
+        this.social = social;
+    }
+
+    public long getUpdateDt() {
+        return updateDt;
+    }
+
+    public void setUpdateDt(long updateDt) {
+        this.updateDt = updateDt;
+    }
+
+    public String getUserId() {
+        return userId;
+    }
+
+    public void setUserId(String userId) {
+        this.userId = userId;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public String getDisplayName() {
+        return displayName;
+    }
+
+    public void setDisplayName(String displayName) {
+        this.displayName = displayName;
+    }
+
+    public String getPortrait() {
+        return portrait;
+    }
+
+    public void setPortrait(String portrait) {
+        this.portrait = portrait;
+    }
+
+    public String getMobile() {
+        return mobile;
+    }
+
+    public void setMobile(String mobile) {
+        this.mobile = mobile;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+
+    public String getCompany() {
+        return company;
+    }
+
+    public void setCompany(String company) {
+        this.company = company;
+    }
+
+    public String getExtra() {
+        return extra;
+    }
+
+    public void setExtra(String extra) {
+        this.extra = extra;
+    }
+
+    public int getGender() {
+        return gender;
+    }
+
+    public void setGender(int gender) {
+        this.gender = gender;
+    }
+}

sdk/src/main/java/cn/wildfirechat/sdk/model/UserId.java

@@ -0,0 +1,17 @@
+package cn.wildfirechat.sdk.model;
+
+public class UserId {
+    private String userId;
+
+    public UserId(String userId) {
+        this.userId = userId;
+    }
+
+    public String getUserId() {
+        return userId;
+    }
+
+    public void setUserId(String userId) {
+        this.userId = userId;
+    }
+}

sdk/src/main/java/cn/wildfirechat/sdk/model/UserName.java

@@ -0,0 +1,17 @@
+package cn.wildfirechat.sdk.model;
+
+public class UserName {
+    private String name;
+
+    public UserName(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

sdk/src/main/java/ikidou/reflect/TypeBuilder.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2016 ikidou
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ikidou.reflect;
+
+import ikidou.reflect.exception.TypeException;
+import ikidou.reflect.typeimpl.ParameterizedTypeImpl;
+import ikidou.reflect.typeimpl.WildcardTypeImpl;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+
+public class TypeBuilder {
+    private final TypeBuilder parent;
+    private final Class raw;
+    private final List<Type> args = new ArrayList<>();
+
+
+    private TypeBuilder(Class raw, TypeBuilder parent) {
+        assert raw != null;
+        this.raw = raw;
+        this.parent = parent;
+    }
+
+    public static TypeBuilder newInstance(Class raw) {
+        return new TypeBuilder(raw, null);
+    }
+
+    private static TypeBuilder newInstance(Class raw, TypeBuilder parent) {
+        return new TypeBuilder(raw, parent);
+    }
+
+
+    public TypeBuilder beginSubType(Class raw) {
+        return newInstance(raw, this);
+    }
+
+    public TypeBuilder endSubType() {
+        if (parent == null) {
+            throw new TypeException("expect beginSubType() before endSubType()");
+        }
+
+        parent.addTypeParam(getType());
+
+        return parent;
+    }
+
+    public TypeBuilder addTypeParam(Class clazz) {
+        return addTypeParam((Type) clazz);
+    }
+
+    public TypeBuilder addTypeParamExtends(Class... classes) {
+        if (classes == null) {
+            throw new NullPointerException("addTypeParamExtends() expect not null Class");
+        }
+
+        WildcardTypeImpl wildcardType = new WildcardTypeImpl(null, classes);
+
+        return addTypeParam(wildcardType);
+    }
+
+    public TypeBuilder addTypeParamSuper(Class... classes) {
+        if (classes == null) {
+            throw new NullPointerException("addTypeParamSuper() expect not null Class");
+        }
+
+        WildcardTypeImpl wildcardType = new WildcardTypeImpl(classes, null);
+
+        return addTypeParam(wildcardType);
+    }
+
+    public TypeBuilder addTypeParam(Type type) {
+        if (type == null) {
+            throw new NullPointerException("addTypeParam expect not null Type");
+        }
+
+        args.add(type);
+
+        return this;
+    }
+
+    public Type build() {
+        if (parent != null) {
+            throw new TypeException("expect endSubType() before build()");
+        }
+
+        return getType();
+    }
+
+    private Type getType() {
+        if (args.isEmpty()) {
+            return raw;
+        }
+        return new ParameterizedTypeImpl(raw, args.toArray(new Type[args.size()]), null);
+    }
+}

sdk/src/main/java/ikidou/reflect/TypeToken.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2016 ikidou
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ikidou.reflect;
+
+import ikidou.reflect.exception.TypeException;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+public abstract class TypeToken<T> {
+    private final Type type;
+
+    public TypeToken() {
+        Type superclass = getClass().getGenericSuperclass();
+        if (superclass instanceof Class) {
+            throw new TypeException("No generics found!");
+        }
+        ParameterizedType type = (ParameterizedType) superclass;
+        this.type = type.getActualTypeArguments()[0];
+    }
+
+    public Type getType() {
+        return type;
+    }
+}

sdk/src/main/java/ikidou/reflect/exception/TypeException.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2016 ikidou
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ikidou.reflect.exception;
+
+public class TypeException extends RuntimeException {
+    public TypeException() {
+    }
+
+    public TypeException(String message) {
+        super(message);
+    }
+
+    public TypeException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public TypeException(Throwable cause) {
+        super(cause);
+    }
+
+    public TypeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}

sdk/src/main/java/ikidou/reflect/typeimpl/ParameterizedTypeImpl.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2016 ikidou
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ikidou.reflect.typeimpl;
+
+import ikidou.reflect.exception.TypeException;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.util.Arrays;
+
+@SuppressWarnings("SpellCheckingInspection")
+public class ParameterizedTypeImpl implements ParameterizedType {
+    private final Class raw;
+    private final Type[] args;
+    private final Type owner;
+
+    public ParameterizedTypeImpl(Class raw, Type[] args, Type owner) {
+        this.raw = raw;
+        this.args = args != null ? args : new Type[0];
+        this.owner = owner;
+        checkArgs();
+    }
+
+    private void checkArgs() {
+        if (raw == null) {
+            throw new TypeException("raw class can't be null");
+        }
+        TypeVariable[] typeParameters = raw.getTypeParameters();
+        if (args.length != 0 && typeParameters.length != args.length) {
+            throw new TypeException(raw.getName() + " expect " + typeParameters.length + " arg(s), got " + args.length);
+        }
+    }
+
+    @Override
+    public Type[] getActualTypeArguments() {
+        return args;
+    }
+
+    @Override
+    public Type getRawType() {
+        return raw;
+    }
+
+    @Override
+    public Type getOwnerType() {
+        return owner;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(raw.getName());
+        if (args.length != 0) {
+            sb.append('<');
+            for (int i = 0; i < args.length; i++) {
+                if (i != 0) {
+                    sb.append(", ");
+                }
+                Type type = args[i];
+                if (type instanceof Class) {
+                    Class clazz = (Class) type;
+
+                    if (clazz.isArray()) {
+                        int count = 0;
+                        do {
+                            count++;
+                            clazz = clazz.getComponentType();
+                        } while (clazz.isArray());
+
+                        sb.append(clazz.getName());
+
+                        for (int j = count; j > 0; j--) {
+                            sb.append("[]");
+                        }
+                    } else {
+                        sb.append(clazz.getName());
+                    }
+                } else {
+                    sb.append(args[i].toString());
+                }
+            }
+            sb.append('>');
+        }
+        return sb.toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        ParameterizedTypeImpl that = (ParameterizedTypeImpl) o;
+
+        if (!raw.equals(that.raw)) return false;
+        // Probably incorrect - comparing Object[] arrays with Arrays.equals
+        if (!Arrays.equals(args, that.args)) return false;
+        return owner != null ? owner.equals(that.owner) : that.owner == null;
+
+    }
+
+    @Override
+    public int hashCode() {
+        int result = raw.hashCode();
+        result = 31 * result + Arrays.hashCode(args);
+        result = 31 * result + (owner != null ? owner.hashCode() : 0);
+        return result;
+    }
+}

sdk/src/main/java/ikidou/reflect/typeimpl/WildcardTypeImpl.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2016 ikidou
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ikidou.reflect.typeimpl;
+
+import java.lang.reflect.Type;
+import java.lang.reflect.WildcardType;
+import java.util.Arrays;
+
+public class WildcardTypeImpl implements WildcardType {
+    private final Class[] upper;
+    private final Class[] lower;
+
+    public WildcardTypeImpl(Class[] lower, Class[] upper) {
+        this.lower = lower != null ? lower : new Class[0];
+        this.upper = upper != null ? upper : new Class[0];
+
+        checkArgs();
+    }
+
+    private void checkArgs() {
+        if (lower.length == 0 && upper.length == 0) {
+            throw new IllegalArgumentException("lower or upper can't be null");
+        }
+
+        checkArgs(lower);
+        checkArgs(upper);
+    }
+
+    private void checkArgs(Class[] args) {
+        for (int i = 1; i < args.length; i++) {
+            Class clazz = args[i];
+            if (!clazz.isInterface()) {
+                throw new IllegalArgumentException(clazz.getName() + " not a interface!");
+            }
+        }
+    }
+
+    @Override
+    public Type[] getUpperBounds() {
+        return upper;
+    }
+
+    @Override
+    public Type[] getLowerBounds() {
+        return lower;
+    }
+
+    @Override
+    public String toString() {
+        if (upper.length > 0) {
+            if (upper[0] == Object.class) {
+                return "?";
+            }
+            return getTypeString("? extends ", upper);
+        } else {
+            return getTypeString("? super ", lower);
+        }
+    }
+
+    private String getTypeString(String prefix, Class[] type) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(prefix);
+
+        for (int i = 0; i < type.length; i++) {
+            if (i != 0) {
+                sb.append(" & ");
+            }
+            sb.append(type[i].getName());
+        }
+
+        return sb.toString();
+
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        WildcardTypeImpl that = (WildcardTypeImpl) o;
+
+        return Arrays.equals(upper, that.upper) && Arrays.equals(lower, that.lower);
+
+    }
+
+    @Override
+    public int hashCode() {
+        int result = Arrays.hashCode(upper);
+        result = 31 * result + Arrays.hashCode(lower);
+        return result;
+    }
+}