import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * Constructor - CycleLog
 * @param plannedStartTime
 * @param actualStartTime
 * @param plannedEndTime
 * @return new CycleLog Object
 */
protected CycleLog (
  long plannedStartTime,
  long actualStartTime,
  long plannedEndTime) {
  
  this.plannedStartTime = plannedStartTime;
  this.actualStartTime = actualStartTime;
  this.plannedEndTime = plannedEndTime;
  this.actualEndTime = this.actualStartTime;
  
  this.nonFatalVangavExceptions = new ArrayList<VangavException>();
  this.nonFatalExceptions = new ArrayList<Exception>();
  
  this.finished = false;
  this.succeeded = false;
  this.failureException = null;
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * checkInstanceOf
 * @param object: the object to be checked
 * @param type: expected class type
 * @param exceptionType: exception type to throw
 *          (bad request or code exception)
 * @throws VangavException
 * */
public static void checkInstanceOf (
  Object object,
  Class<?> type,
  ExceptionType exceptionType) throws Exception {
  
  if (object.getClass().equals(type) == false) {
    
    throw VangavException.exceptionFactory(
      41,
      1,
      "Wrong class type ["
      + object.getClass().getName()
      + "] expecting ["
      + type.getName()
      + "]",
      exceptionType,
      ExceptionClass.ARGUMENT);
  }
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * checkNotNull
 * @param name: name of the object to be checked
 * @param object: object to be checked
 * @param exceptionType: exception type to throw
 *          (bad request or code exception)
 * @throws VangavException
 * */
public static void checkNotNull (
  String name,
  Object object,
  ExceptionType exceptionType) throws Exception {
  
  if (object == null) {
    
    throw VangavException.exceptionFactory(
      41,
      2,
      name
      + " can't be null",
      exceptionType,
      ExceptionClass.ARGUMENT);
  }
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * checkNotEmpty
 * @param name
 * @param string
 * @param exceptionType
 * @throws Exception if param string is null or empty
 */
public static void checkNotEmpty (
  String name,
  String string,
  ExceptionType exceptionType) throws Exception {
  
  checkNotNull(name, string, exceptionType);
  
  if (string.length() == 0) {
    
    throw VangavException.exceptionFactory(
      41,
      3,
      name
      + " can't be empty",
      exceptionType,
      ExceptionClass.ARGUMENT);
  }
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * checkIntWithinRange
 * @param name: name of the integer to be checked
 * @param value: value of the integer to be checked
 * @param min: minimum valid value
 * @param max: maximum valid value
 * @param exceptionType: exception type to throw
 *          (bad request or code exception)
 * @throws VangavException
 * */
public static void checkIntWithinRange (
  String name,
  int value,
  int min,
  int max,
  ExceptionType exceptionType) throws Exception {
  
  if (value < min || value > max) {
    
    throw VangavException.exceptionFactory(
      41,
      12,
      name
      + " value ["
      + value
      + "] min ["
      + min
      + "] max ["
      + max
      + "] is out of range",
      exceptionType,
      ExceptionClass.ARGUMENT);
  }
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * checkIntGreaterThanOrEqual
 * @param name: name of the integer to be checked
 * @param value: value of the integer to be checked
 * @param minLimit: minimum valid value
 * @param exceptionType: exception type to throw
 *          (bad request or code exception)
 * @throws VangavException
 * */
public static void checkIntGreaterThanOrEqual (
  String name,
  int value,
  int minLimit,
  ExceptionType exceptionType) throws Exception {
  
  if (value < minLimit) {
    
    throw VangavException.exceptionFactory(
      41,
      13,
      name
      + " value ["
      + value
      + "] min limit ["
      + minLimit
      + "] is less than the minimum limit",
      exceptionType,
      ExceptionClass.ARGUMENT);
  }
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * checkLongGreaterThanOrEqual
 * @param name: name of the long to be checked
 * @param value: value of the long to be checked
 * @param minLimit: minimum valid value
 * @param exceptionType: exception type to throw
 *          (bad request or code exception)
 * @throws VangavException
 * */
public static void checkLongGreaterThanOrEqual (
  String name,
  long value,
  long minLimit,
  ExceptionType exceptionType) throws Exception {
  
  if (value < minLimit) {
    
    throw VangavException.exceptionFactory(
      41,
      14,
      name
      + " value ["
      + value
      + "] min limit ["
      + minLimit
      + "] is less than the minimum limit",
      exceptionType,
      ExceptionClass.ARGUMENT);
  }
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * checkDoubleHasValue
 * throws an exception is param value is NAN or infinite
 * @param name
 * @param value
 * @param exceptionType
 * @throws Exception
 */
public static void checkDoubleHasValue (
  String name,
  double value,
  ExceptionType exceptionType) throws Exception {
  
  if (Double.isNaN(value) || Double.isInfinite(value) ) {
   
    throw VangavException.exceptionFactory(
      41,
      15,
      name
      + " double ["
      + value
      + "] has no value",
      exceptionType,
      ExceptionClass.ARGUMENT);
  }
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * Constructor Request
 * @param request (play framework request)
 * @param requestJsonBody
 * @param responseBody
 * @param controllerName
 * @return new Request Object
 * @throws Exception
 */
public Request (
  play.mvc.Http.Request request,
  RequestJsonBody requestJsonBody,
  ResponseBody responseBody,
  String controllerName) throws Exception {
  
  this.startTime = System.currentTimeMillis();
  this.startCalendar =
    CalendarAndDateOperationsInl.getCalendarFromUnixTime(this.startTime);
  this.endTime = this.startTime;
  this.execTime = 0;
  
  this.requestId = UUID.randomUUID();
  this.header = new RequestHeader(request);
  this.body = requestJsonBody;
  this.response = responseBody;
  this.dispatcher = new Dispatcher();
  
  this.controllerName = controllerName;
  this.userId = this.body.getUserId();
  this.isThrottled = false;
  
  this.state = RequestState.OK;
  this.vangavExceptions = new ArrayList<VangavException>();
  this.exceptions = new ArrayList<Exception>();
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * checkIpV4
 * throws an exception if param ip isn't a valid IP V4
 * @param name
 * @param ip
 * @param exceptionType
 * @throws Exception
 */
public static void checkIpV4 (
  String name,
  String ip,
  ExceptionType exceptionType) throws Exception {
  
  try {
    
    String [] ipSplit = ip.split("\\.");
    int currValue;
    
    for (int i = 0; i < 4; i ++) {
      
      currValue = Integer.parseInt(ipSplit[i] );
      
      checkIntWithinRange(
        "",
        currValue,
        0,
        255,
        exceptionType);
    }
  } catch (Exception e) {
    
    throw VangavException.exceptionFactory(
      41,
      16,
      name
      + " Invalid IP V4 ["
      + ip
      + "]",
      exceptionType,
      ExceptionClass.ARGUMENT);
  }
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * endCallWithExceptions
 * used instead of endCall in case an exception got thrown during processing
 * invoked at the end of each call from ControllerCall's run method to
 *   complete a controller's call log
 * @param e
 */
protected void endCallWithExceptions (Exception e) {
  
  this.requestToResponseTimeInMilliSeconds =
    (int) (System.currentTimeMillis() - this.startTime);
  
  this.responseHttpStatusCode = -2;
  this.response = ErrorResponse.getDefaultErrorResponse();
  
  this.threwExceptionsDuringCall = true;
  this.thrownException = VangavException.getExceptionStackTrace(e);
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * getNonFatalVangavExceptions
 * @return this cycle's non-fatal vangav exceptions
 * @throws Exception
 */
public ArrayList<VangavException> getNonFatalVangavExceptions (
  ) throws Exception {
  
  return this.nonFatalVangavExceptions;
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * getNonFatalExceptionsAsString
 * @return this cycle's non fatal exceptions in string form for the toString
 *           method
 */
private ArrayList<String> getNonFatalExceptionsAsString () {
  
  ArrayList<String> result = new ArrayList<String>();
  
  try {
    
    for (Exception exception : this.nonFatalExceptions) {
      
      if (exception instanceof VangavException) {
        
        result.add(((VangavException)exception).toString() );
      } else {
        
        result.add(VangavException.getExceptionStackTrace(exception) );
      }
    }
  } catch (Exception e) {
    
    result.add("Failed to continue because of an exception");
  }
  
  return result;
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * getFailureExceptionAsString
 * @return this cycle's failure exception in string form for the toString
 *           method
 */
private String getFailureExceptionAsString () {
  
  if (this.failureException == null) {
    
    return "no failure exception";
  }
  
  if (this.failureException instanceof VangavException) {
    
    return ((VangavException)this.failureException).toString();
  } else {
    
    return VangavException.getExceptionStackTrace(this.failureException);
  }
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * getAllExceptionsAsString
 * @return both VangavException and Exception exceptions' stack traces as
 *           as a String
 * @throws Exception
 */
public String getAllExceptionsAsString () throws Exception {
  
  StringBuffer stringBuffer = new StringBuffer();
  
  stringBuffer.append("VANGAV EXCEPTIONS\n\n");
  
  for (VangavException vangavException : this.vangavExceptions) {
    
    stringBuffer.append(vangavException.toString() );
    stringBuffer.append("\n\n");
  }
  
  stringBuffer.append("\n\nEXCEPTIONS\n\n");
  
  for (Exception exception : this.exceptions) {
    
    stringBuffer.append(VangavException.getExceptionStackTrace(exception) );
    stringBuffer.append("\n\n");
  }
  
  return stringBuffer.toString();
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * getTheLastVangavException
 * @return the last thrown VangavException (i.e.: the fatal exception that
 *           caused this request to fail) and null if vangav exceptions' list
 *           is empty
 * @throws Exception
 */
public VangavException getTheLastVangavException () throws Exception {
  
  if (this.vangavExceptions.isEmpty() == true) {
    
    return null;
  }
  
  return this.vangavExceptions.get(this.vangavExceptions.size() - 1);
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * addNonFatalVangavException
 * used to add a VangavException that occurs during processing a cycle but
 *   doesn't cause it to fail
 * @param ve
 * @throws Exception
 */
public void addNonFatalVangavException (
  VangavException ve) throws Exception {
  
  this.nonFatalVangavExceptions.add(ve);
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * Constructor ResponseBodyError
 * @param vangavException
 * @return new ResponseBodyError Object
 * @throws Exception
 */
public ResponseBodyError (VangavException vangavException) throws Exception {
  
  this(vangavException, UUID.fromString(kDefaultErrorTraceId) );
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * addVangavException
 * when exceptions happen they are added to the request object to be used
 *   for response, analysis, logging, etc ...
 * @param vangavException
 */
public void addVangavException (
  VangavException vangavException) throws Exception {
  
  this.vangavExceptions.add(vangavException);
}
 

import com.vangav.backend.exceptions.VangavException; //导入依赖的package包/类
/**
 * getVangavExceptions
 * @return arraylist of Vangav Exceptions that occured during the processing
 *           of this request
 */
public ArrayList<VangavException> getVangavExceptions () throws Exception {
  
  return this.vangavExceptions;
}