Page Comparison

import flexagon.fd.model.integration.cms.api.CMSObject;
import flexagon.fd.model.integration.cms.api.ChangeManagementSystem;
import flexagon.fd.model.integration.util.ApiException;

import java.io.Serializable;
import java.io.StringReader;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.json.Json;
import javax.json.JsonObject;
import javax.json.JsonObjectBuilder;
import javax.json.JsonReader;

import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

import org.glassfish.jersey.client.ClientConfig;
import org.glassfish.jersey.client.ClientProperties;
import org.glassfish.jersey.client.HttpUrlConnectorProvider;
import org.glassfish.jersey.filter.LoggingFilter;
import flexagon.fd.model.integration.cms.impl.CMSObjectImpl


class ZendeskGroovyIntegration {
  def className = ZendeskGroovyIntegration.class.getName();
  String mAccessToken;
  Client mRestClient;
  def now = new Date();  
  
    private void getOAuthAccessToken(String pScope)
    throws ApiException
  {
    JsonObjectBuilder zenOAuthRequestJson = Json.createObjectBuilder();
    zenOAuthRequestJson.add("grant_type", "password");
    zenOAuthRequestJson.add("client_id", getClientId());
    zenOAuthRequestJson.add("client_secret", getClientSecret());
    zenOAuthRequestJson.add("username", getUserName());
    zenOAuthRequestJson.add("password", getPassword());
    zenOAuthRequestJson.add("scope", pScope);
    String payLoad = zenOAuthRequestJson.build().toString();
    Response clientResponse =
      getRestClient().target(getZendeskDomain()).path(getOAuthURI()).request(MediaType.APPLICATION_JSON_TYPE).accept(MediaType.APPLICATION_JSON_TYPE).post(Entity.json(payLoad));
    checkResponse(clientResponse);
    JsonObject jsonResponseObject = readJsonObject(clientResponse.readEntity(String.class));
    System.out.println("OAuth Response " + jsonResponseObject);
    mAccessToken = jsonResponseObject.getString("access_token");
  }
  
    private void checkResponse(Response clientResponse)
    throws ApiException
  {
    String methodName = "checkResponse";
    log.logFinestEntering(methodName, clientResponse);  
    print(methodName + String.format(" Invoked connection URL %s", clientResponse));
    int statusCode = clientResponse.getStatusInfo().getStatusCode();
    if (statusCode == 401)
    {
      throw new ApiException("Invalid credentials.", "");
    }
    if (!(clientResponse.getStatusInfo().getFamily() == Response.Status.Family.SUCCESSFUL))
    {
      throw new ApiException(clientResponse.toString(), clientResponse.getStatusInfo().getReasonPhrase());
    }
    log.logFinestExiting(methodName);  
  }
  
  def createTicket(Map<String,Serializable> pTicketFields)
  {
    String methodName = "createTicket";  
    log.logFinestEntering(methodName, pTicketFields);  
    CMSObject ticket = postTicket("request", ZD_REQUEST_CREATE_PATTERN, "question", "requests:write read", pTicketFields);
    log.logFinestExiting(methodName, ticket);  
    return ticket;
  }
  
    private CMSObject postTicket(String pObjectType, String pURLKey, String pTicketType, String pScope, Map<String, Serializable> pTicketFields)
    throws ApiException
  {
    String methodName = "postTicket";
    log.logFinestEntering(methodName, pTicketFields);  
    JsonObjectBuilder zenInputJson = Json.createObjectBuilder();
	Serializable requestor = pTicketFields.remove("requester_id");
	JsonObjectBuilder reqParamJsonBuider = null
	if(requestor != null)
	{
	  reqParamJsonBuider = Json.createObjectBuilder();
	  reqParamJsonBuider.add("name", requestor.toString())
	}
	Serializable description = pTicketFields.remove("description");
	JsonObjectBuilder desParamJsonBuider = null
	if(description != null)
	{
	  desParamJsonBuider = Json.createObjectBuilder();
	  desParamJsonBuider.add("body", description.toString())
	}
	JsonObjectBuilder inputJsonObject = buildJsonRequest(pTicketFields)
	if(requestor != null)
	{
		inputJsonObject.add("requester", reqParamJsonBuider.build())
	}
	if(description != null)
	{
		inputJsonObject.add("comment", desParamJsonBuider.build())
	}
    zenInputJson.add(pObjectType,  inputJsonObject);

    WebTarget postRequest = getWebResource(pURLKey);//getPropertyAsString(pURLKey)
    String payLoad = zenInputJson.build().toString();
    print(methodName + String.format(" Creating new %s %s", pObjectType, payLoad));
    Response clientResponse = postRequest.request(MediaType.APPLICATION_JSON_TYPE).accept(MediaType.APPLICATION_JSON_TYPE).header("Authorization", getAccessToken(pScope)).post(Entity.json(payLoad));
    checkResponse(clientResponse);
    JsonObject jsonResponseObject = readJsonObject(clientResponse.readEntity(String.class));
    JsonObject requestResponseJson = jsonResponseObject.getJsonObject(pObjectType);
    CMSObject request = createTicketFromJson(requestResponseJson, ChangeManagementSystem.CMSObjectType.TICKET);
    print(methodName + String.format(" Successfully created ticket %s", request.getNumber()));
    log.logFinestExiting(methodName, request);  
    return request;
  }
  
    private CMSObject createTicketFromJson(JsonObject jsonObject, ChangeManagementSystem.CMSObjectType pType)
  {
    String methodName = "createTicketFromJson";
     log.logFinestEntering(methodName, jsonObject, pType);  

    CMSObject ticket = CMSObjectImpl.getInstance(String.valueOf(jsonObject.getInt("id")), pType, jsonObject, jsonObject.getString("description"));

    log.logFinestExiting(methodName, ticket);  
    return ticket;
  }

  private JsonObject readJsonObject(String source)
  {
    String methodName = "readJsonObject";
    log.logFinestEntering(methodName, source);  
    JsonReader jsonReader = Json.createReader(new StringReader(source));
    JsonObject object = null;
    try
    {
      object = jsonReader.readObject();
      print(methodName + String.format(" Json object created for response = %s", source));
    }
    catch (Exception e)
    {
      print(methodName + String.format(" Exception while creating response json object, error %s, response = %s", e.getMessage(), source));
      print(methodName + " - " + e.getStackTrace());
    }
    finally
    {
      if (jsonReader != null)
      {
        jsonReader.close();
      }
    }
    log.logFinestExiting(methodName, object);  
    return object;
  }
  
  def createIncident(Map<String,Serializable> pIncidentFields)
  {
    String methodName = "createIncident";  
    log.logFinestEntering(methodName, pIncidentFields);
    CMSObject incident = postTicket("ticket", ZD_TICKET_CREATE_PATTERN, "incident", "tickets:write read", pIncidentFields);
    log.logFinestExiting(methodName, incident);
    return incident;
  }
  
  def findCMSObjectByType(String pCMSObjectNumber, ChangeManagementSystem.CMSObjectType pCMSObjectType)
  {
    String methodName = "findCMSObjectByType";
    log.logFinestEntering(methodName, pCMSObjectNumber, pCMSObjectType);
	CMSObject ticket = getChangeRequest(pCMSObjectNumber);
    log.logFinestExiting(methodName, ticket);
    return ticket;
  }
  
    private CMSObject getChangeRequest(String pRequestNumber)
    throws ApiException
  {
    return getTicket("request", ZD_REQUEST_GET_PATTERN, pRequestNumber, "{ZENDESK_REQUEST}");
  }
  
    private CMSObject getTicket(String pObjectType, String pURLKey, String pRequestNumber, String pSearchPattern)
    throws ApiException
  {
    String methodName = "getTicket";
    log.logFinestEntering(methodName);

    String urlString = pURLKey;//getPropertyAsString(pURLKey);

    urlString = urlString.replace(pSearchPattern, pRequestNumber);
    Response clientResponse = getWebResource(urlString).request(MediaType.APPLICATION_JSON_TYPE).header("Authorization", getAccessToken("tickets:write read")).get(Response.class);
    checkResponse(clientResponse);
    JsonObject jsonResponseObject = readJsonObject(clientResponse.readEntity(String.class));
    JsonObject ticketResponseJson = jsonResponseObject.getJsonObject(pObjectType);
    CMSObject ticket = createTicketFromJson(ticketResponseJson, ChangeManagementSystem.CMSObjectType.TICKET);
    print(methodName + String.format(" Successfully found ticket %s", ticket.getNumber()));
    log.logFinestExiting(methodName, ticket);
    return ticket;
  }
  
  def findTicketByType(String pTicketNumber)
  {
    String methodName = "findTicketByType";
    log.logFinestEntering(methodName, pTicketNumber);
    CMSObject ticket = findCMSObjectByType(pTicketNumber, ChangeManagementSystem.CMSObjectType.TICKET);
    log.logFinestExiting(methodName, ticket);
    return ticket;
  }

  def isTicketApproved(CMSObject pTicket, String pEnvironmentCode)
  {
    String methodName = "isTicketApproved";
    log.logFinestEntering(methodName, pTicket, pEnvironmentCode);
    CMSObject findRequest = pTicket;
    Boolean approved = false;
    try
    {
      if (findRequest != null)
      {
        String status = findRequest.getJson().getString("status");
        print(String.format("#[%s] status [%s]", pTicket.getNumber(), status));
        if ("solved".equalsIgnoreCase(status))
        {
          approved = true;
        }
      }
    }
    catch (Exception e)
    {
      // TODO: Add catch code
    }
    log.logFinestExiting(methodName, approved);
    return approved;
  }
  
  def isTicketRejected(CMSObject pTicket, String pEnvironmentCode)
  {
    String methodName = "isTicketRejected()";
    log.logFinestEntering(methodName, pTicket, pEnvironmentCode);
    CMSObject findRequest = pTicket;
    Boolean rejected = false;
    try
    {
      if (findRequest != null)
      {
        String status = findRequest.getJson().getString("status");
        print(String.format("#[%s] status [%s] script[%s]", pTicket.getNumber(), status, ZD_REJECTED_SCRIPT));
        if ((!"New".equalsIgnoreCase(status)) && ("on-hold".equalsIgnoreCase(status) || "pending".equalsIgnoreCase(status)))
        {
          rejected = true;
        }
      }
    }
    catch (Exception e)
    {
      // TODO: Add catch code
    }
    log.logFinestExiting(methodName, rejected);
    return rejected;
  }
  
  def isDoPolling()
  {
    String methodName = "isDoPolling()";
    log.logFinestEntering(methodName);
	boolean flag = true;
    log.logFinestExiting(methodName, flag);
	return flag;
  }
  
    private void print(String pText)
  {
    System.out.println(String.format("%s %s", now.toString(), pText));
  }

  private String getUserName()
  {
    return ZD_USER_NAME;
  }


  private String getPassword()
  {
    return ZD_PASSWORD;
  }
  
  def checkConnection()
  {
    String methodName = "checkConnection()";
    log.logFinestEntering(methodName);
    try  
    {
		print(methodName + " getting user details to check connection");
		Response clientResponse = getWebResource("/api/v2/users/me.json").request(MediaType.APPLICATION_JSON_TYPE).header("Authorization", getAccessToken("organizations:write read")).get(Response.class);
		checkResponse(clientResponse);
		print(methodName + " Test connection response code looks valid, check content of response");
		String responseString = clientResponse.readEntity(String.class);
		print(methodName + "responseString=" + responseString + ", Validated that JSON data was received from test connction URL invocation.");
    }
    catch (Exception e)
    {
      log.logInfo(methodName, " Test connection failed " + e.getMessage() + " " + e)
      throw new ApiException("Connection failed. " + e.getMessage());  
    }
    log.logFinestExiting(methodName);
  }
  
    private Client getRestClient()
    throws ApiException
  {
    if (mRestClient == null)
    {
      ClientBuilder builder;
      builder = ClientBuilder.newBuilder().withConfig(new ClientConfig().register(LoggingFilter.class)).property(HttpUrlConnectorProvider.SET_METHOD_WORKAROUND, true);
      mRestClient = builder.build();
      mRestClient.property(ClientProperties.CONNECT_TIMEOUT, 10000);
      mRestClient.property(ClientProperties.READ_TIMEOUT, 20000);
    }
    return mRestClient;
  }
  
    private WebTarget getWebResource(String resource)
    throws ApiException
  {
    if (resource != null && !resource.isEmpty() && !resource.startsWith("/"))
    {
      resource += "/" + resource;
    }
    WebTarget webResource = null;
    try
    {
      webResource = getRestClient().target(getZendeskDomain()).path(resource);
    }
    catch (Exception e)
    {
      throw new ApiException(e.getMessage(), e.getMessage());
    }

    return webResource;
  }

  private String getAccessToken(String pScope)
    throws ApiException
  {
    getOAuthAccessToken(pScope);
    return "Bearer " + mAccessToken;
  }

  private String getOAuthURI()
  {
    return ZD_OAUTH_URI;
  }

  private String getClientId()
  {
    return ZD_CLIENT_ID;
  }

  private String getClientSecret()
  {
    return ZD_CLIENT_SECRET;
  }
  
    protected JsonObjectBuilder buildJsonRequest(Map<String, Serializable> pFields)
  {
    String methodName = "buildJsonRequest";
    JsonObjectBuilder jsonBuider = Json.createObjectBuilder();

    for (String fieldKey: pFields.keySet())
    {
      Serializable fieldValue = pFields.get(fieldKey);

      if (fieldValue != null)
      {
        if (fieldValue instanceof String)
        {
          jsonBuider.add(fieldKey, (String) fieldValue);
        }
        else if (fieldValue instanceof Boolean)
        {
          jsonBuider.add(fieldKey, (Boolean) fieldValue);
        }
        else if (fieldValue instanceof Integer)
        {
          jsonBuider.add(fieldKey, (Integer) fieldValue);
        }
        else if (fieldValue instanceof Float)
        {
          jsonBuider.add(fieldKey, (Float) fieldValue);
        }
        else if (fieldValue instanceof Double)
        {
          jsonBuider.add(fieldKey, (Double) fieldValue);
        }
        else if (fieldValue instanceof Long)
        {
          jsonBuider.add(fieldKey, (Long) fieldValue);
        }
        else
        {
          // convert to String if type unknown
          jsonBuider.add(fieldKey, fieldValue.toString());
        }
      }
    }
    return jsonBuider;
  }
  
    private String getZendeskDomain()
  {
    return getZendeskURLBuilder().toString();
  }

  private StringBuilder getZendeskURLBuilder()
  {
    StringBuilder urlBuilder = new StringBuilder(ZD_DOMAIN_NAME);
    return urlBuilder;
  }
}