com.sonymobile.tools.gerrit.gerritevents.GerritJsonEventFactory Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gerrit-events Show documentation
Java client library for receiving stream-events from Gerrit code review. As well as performing queries and sending reviews.
The newest version!
/*
 *  The MIT License
 *
 *  Copyright 2010 Sony Mobile Communications Inc. All rights reserved.
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
 *  in the Software without restriction, including without limitation the rights
 *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *  copies of the Software, and to permit persons to whom the Software is
 *  furnished to do so, subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in
 *  all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 *  THE SOFTWARE.
 */
package com.sonymobile.tools.gerrit.gerritevents;

import com.sonymobile.tools.gerrit.gerritevents.dto.GerritEventType;
import com.sonymobile.tools.gerrit.gerritevents.dto.GerritJsonEvent;
import java.lang.reflect.Constructor;
import java.util.Date;
import java.util.concurrent.TimeUnit;

import net.sf.json.JSONException;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Contains utility methods for handling JSONObjects.
 * @author Robert Sandell <[email protected]>
 */
public final class GerritJsonEventFactory {

    private static final Logger logger = LoggerFactory.getLogger(GerritJsonEventFactory.class);

    /**
     * Empty private Constructor to hinder instantiation.
     */
    private GerritJsonEventFactory() {
        //Empty
    }

    /**
     * Creates a GerritJsonEvent DTO out of the provided JSONObject.
     * The jsonObject is assumed to be interesting and usable
     * as defined by {@link #getJsonObjectIfInterestingAndUsable(java.lang.String) }
     * @param jsonObject the parsed JSON Object
     * @return the POJO DTO representation of the jsonObject.
     */
    public static GerritJsonEvent getEvent(JSONObject jsonObject) {

        GerritEventType type = GerritEventType.findByTypeValue(jsonObject.getString("type"));
        //the type has already been verified by the method that gets the JSONObject,
        //so any NullPointerExceptions or similar problems are the caller's own fault.
        Class clazz = type.getEventRepresentative();
        GerritJsonEvent event = null;
        try {
            logger.debug("Interesting event with a class defined. Searching shorthand constructor.");
            Constructor constructor = clazz.getConstructor(JSONObject.class);
            event = constructor.newInstance(jsonObject);
            logger.trace("Event created from shorthand constructor.");
        } catch (NoSuchMethodException ex) {
            logger.debug("Constructor with JSONObject as parameter missing, trying default constructor.", ex);
        } catch (Exception ex) {
            logger.debug("Error when using event constructor with JSONObject, trying default constructor.", ex);
        }
        if (event == null) {
            logger.debug("Trying default constructor.");
            try {
                event = clazz.newInstance();
                event.fromJson(jsonObject);
                logger.trace("Event created from default constructor");
            } catch (InstantiationException ex) {
                logger.error("Could not create an interesting GerritJsonEvent via default constructor "
                        + "(DESIGN ERROR).", ex);
            } catch (IllegalAccessException ex) {
                logger.error("Could not create an interesting GerritJsonEvent via default constructor"
                        + "(DESIGN ERROR).", ex);
            }
        }
        logger.debug("Returning an event: {}", event);
        return event;
    }

    /**
     * Tells if the provided string is a valid JSON string
     * and represents an interesting and usable {@link GerritJsonEvent}
     * as defined by {@link #getJsonObjectIfInterestingAndUsable(java.lang.String) }.
     * This is the same as doing {@code (getJsonObjectIfInterestingAndUsable(jsonString) != null)}
     * @param jsonString the JSON formatted String.
     * @return true if it is so.
     */
    public static boolean isInterestingAndUsable(String jsonString) {
        return getJsonObjectIfInterestingAndUsable(jsonString) != null;
    }

    /**
     * Tries to parse the provided string into a JSONObject and returns it if it is interesting and usable.
     * If it is interesting is determined by:
     * 
     *  The object contains a String field named type
     *  The String returns a non null GerritEventType from
     *      {@link GerritEventType#findByTypeValue(java.lang.String) }
     *  The property {@link GerritEventType#isInteresting() } == true
     * 
     * It is usable if the type's {@link GerritEventType#getEventRepresentative() } is not null.
     * @param jsonString the string to parse.
     * @return an interesting and usable JSONObject, or null if it is not.
     */
    public static JSONObject getJsonObjectIfInterestingAndUsable(String jsonString) {
        logger.trace("finding event for jsonString: {}", jsonString);
        if (jsonString == null || jsonString.length() <= 0) {
            return null;
        }
        try {
            JSONObject jsonObject = (JSONObject)JSONSerializer.toJSON(jsonString);
            logger.debug("Parsed a JSONObject");
            if (isInterestingAndUsable(jsonObject)) {
                return jsonObject;
            }
        } catch (Exception ex) {
            logger.warn("Unanticipated error when examining JSON String", ex);
        }
        return null;
    }

    /**
     * Deprecated due to misspelling.
     * Use isInterestingAndUsable instead.
     * @param json the string to parse
     * @return true if an interesting and usable JSONObject.
     */
    @Deprecated
    public static boolean isInteresgingAndUsable(JSONObject json) {
        return isInterestingAndUsable(json);
    }
    /**
     * Check if it is interesting and usable. If it is interesting is determined by:
     * 
     *  The object contains a String field named type
     *  The String returns a non null GerritEventType from
     *      {@link GerritEventType#findByTypeValue(java.lang.String) }
     *  The property {@link GerritEventType#isInteresting() } == true
     * 
     * It is usable if the type's {@link GerritEventType#getEventRepresentative() } is not null.
     * @param json the string to parse.
     * @return true if an interesting and usable JSONObject.
     */
    public static boolean isInterestingAndUsable(JSONObject json) {
        try {
            if (json != null) {
                if (json.get("type") != null) {
                    logger.trace("It has a type");
                    GerritEventType type = GerritEventType.findByTypeValue(json.getString("type"));
                    logger.debug("Type found: {}", type);
                    if (type != null && type.isInteresting() && type.getEventRepresentative() != null) {
                        logger.debug("It is interesting and usable.");
                        return true;
                    }
                }
            }
        } catch (Exception ex) {
            logger.warn("Unanticipated error when examining JSON String.");
        }
        return false;
    }

    /**
     * Tries to parse the provided string into a GerritJsonEvent DTO if it is interesting and usable.
     * @param jsonString the JSON formatted string.
     * @return the Event.
     * @see #getJsonObjectIfInterestingAndUsable(String)
     */
    public static GerritJsonEvent getEventIfInteresting(String jsonString) {
        logger.trace("finding event for jsonString: {}", jsonString);
        try {
            JSONObject jsonObject = getJsonObjectIfInterestingAndUsable(jsonString);
            if (jsonObject != null) {
                return getEvent(jsonObject);
            }

        } catch (Exception ex) {
            logger.warn("Unanticipated error when creating DTO representation of JSON string.", ex);
        }
        return null;
    }

    /**
     * Returns the value of a JSON property as a String if it exists otherwise returns the defaultValue.
     * @param json the JSONObject to check.
     * @param key the key.
     * @param defaultValue the value to return if the key is missing.
     * @return the value for the key as a string.
     */
    public static String getString(JSONObject json, String key, String defaultValue) {
        if (json.containsKey(key)) {
            return json.getString(key);
        } else {
            return defaultValue;
        }
    }

    /**
     * Returns the value of a JSON property as a String if it exists otherwise returns null.
     * Same as calling {@link #getString(net.sf.json.JSONObject, java.lang.String, java.lang.String) }
     * with null as defaultValue.
     * @param json the JSONObject to check.
     * @param key the key.
     * @return the value for the key as a string.
     */
    public static String getString(JSONObject json, String key) {
        return getString(json, key, null);
    }

    /**
     * Returns the value of a JSON property as a boolean if it exists and boolean value
     * otherwise returns the defaultValue.
     * @param json the JSONObject to check.
     * @param key the key.
     * @param defaultValue the value to return if the key is missing or not boolean value.
     * @return the value for the key as a boolean.
     */
    public static boolean getBoolean(JSONObject json, String key, boolean defaultValue) {
        if (json.containsKey(key)) {
            boolean result;
            try {
                result = json.getBoolean(key);
            } catch (JSONException ex) {
                result = defaultValue;
            }
            return result;
        } else {
            return defaultValue;
        }
    }

    /**
     * Returns the value of a JSON property as a boolean if it exists otherwise returns false.
     * @param json the JSONObject to check.
     * @param key the key.
     * @return the value for the key as a boolean.
     */
    public static boolean getBoolean(JSONObject json, String key) {
        return getBoolean(json, key, false);
    }

    /**
     * Returns the value of a JSON property as a Date if it exists otherwise returns null.
     * @param json the JSONObject to check.
     * @param key the key.
     * @return the value for the key as a Date.
     */
    public static Date getDate(JSONObject json, String key) {
        return getDate(json, key, null);
    }

    /**
     * Returns the value of a JSON property as a Date if it exists otherwise returns the defaultValue.
     * @param json the JSONObject to check.
     * @param key the key.
     * @param defaultValue the value to return if the key is missing.
     * @return the value for the key as a Date.
     */
    public static Date getDate(JSONObject json, String key, Date defaultValue) {
        Date result = defaultValue;
        if (json.containsKey(key)) {
            try {
                String secondsString = json.getString(key);
                //In gerrit, time is written in seconds, not milliseconds.
                Long milliseconds = TimeUnit.SECONDS.toMillis(Long.parseLong(secondsString));
                result = new Date(milliseconds);
                // CS IGNORE EmptyBlockCheck FOR NEXT 2 LINES. REASON: result is already set to defaultValue.
            } catch (JSONException ex) {
            } catch (NumberFormatException nfe) {
            }
        }
        return result;
    }
}