Source: src/main/javascript/oracle/oj/ojmessaging/Message.js

/**
 * Copyright (c) 2014, Oracle and/or its affiliates.
 * All rights reserved.
 */

/**
 * Constructs a message object 
 * .
 * @param {string} summary - Localized summary message text
 * @param {string} detail - Localized detail message text 
 * @param {number|string=} severity - An optional severity for this message. Use constants 
 * oj.Message.SEVERITY_LEVEL for number types and oj.Message.SEVERITY_TYPE for string types. Default 
 * is SEVERITY_ERROR if no severity is specified
 * @constructor
 * @export
 * @since 0.6
 */
oj.Message = function(summary, detail, severity)
{
  this.Init(summary, detail, severity);
};

/**
 * Indicates the type of severity that the message represents. 
 * @enum {string}
 * @export 
 */
oj.Message.SEVERITY_TYPE = {
  /**
   * Indicates a confirmation that an operation or task was completed. This is the lowest severity 
   * level.
   */
  'CONFIRMATION': 'confirmation',

  /**
   * Indicates information or operation messages. This has a lower severity level than warning.
   */
  'INFO':'info',

  /**
   * Indicates an application condition or situation that might require users' attention. This has a 
   * lower severity than error.
   */
  'WARNING': 'warning',

  /**
   * Used when data inaccuracies occur when completing a field and that needs fixing before user can 
   * continue. This has a lower severity level than fatal.
   * fatal.
   */
  'ERROR': 'error',

  /**
   * Used when a critical application error or an unknown failure occurs. This is the highest 
   * severity level. 
   * @const
   * @export 
   */
  'FATAL': 'fatal'
};


/**
 * Message severity level
 * @enum {number}
 * @export
 */
oj.Message.SEVERITY_LEVEL = {
  'FATAL' : 5,
  'ERROR' : 4,
  'WARNING' : 3,
  'INFO' : 2,
  'CONFIRMATION' : 1
};

// Subclass from oj.Object 
oj.Object.createSubclass(oj.Message, oj.Object, "oj.Message");

/**
 * Localized summary text.
 * 
 * @member
 * @name summary
 * @memberof oj.Message
 * @instance
 * @type {string}
 * @default <code class="prettyprint">""</code>
 */

/**
 * Localized detail text.
 * 
 * @member
 * @name detail
 * @memberof oj.Message
 * @instance
 * @type {string}
 * @default <code class="prettyprint">""</code>
 */

/**
 * Severity type of message. See oj.Message.SEVERITY_TYPE.
 * 
 * @member
 * @name severity
 * @memberof oj.Message
 * @instance
 * @type {string}
 * @default <code class="prettyprint">oj.Message.SEVERITY_TYPE.ERROR</code>
 */

/**
 * Initializes Message instance with the set options
 * @param {string} summary a localized summary message text
 * @param {string} detail a localized detail message text 
 * @param {number|string=} severity - An optional severity for this message.  Use constants 
 * oj.Message.SEVERITY_LEVEL for number types and oj.Message.SEVERITY_TYPE for string types.
 *                   
 * @export
 */
oj.Message.prototype.Init = function(summary, detail, severity) 
{
  oj.Message.superclass.Init.call(this);
  this['summary'] = summary;
  this['detail'] = detail;
  this['severity'] = severity || oj.Message.SEVERITY_TYPE.ERROR; // defaults to ERROR
};

/**
 * Whether a message can display on the UI. 
 * 
 * @memberof! oj.Message
 * @returns {boolean} always returns true; 
 * @instance
 * @protected 
 * @since 0.7
 */
oj.Message.prototype.canDisplay = function ()
{
  return true;
};

/**
 * Indicates whether some other oj.Message instance - msg,  is "equal to" this one.
 * Method is equivalent to java ".equals()" method.
 * 
 * @param {Object} msg 
 * @memberof oj.Message
 * @export
 */
oj.Message.prototype.equals = function (msg)
{
  if (msg)
  {
    if ((oj.Message.getSeverityLevel(this['severity']) === 
            oj.Message.getSeverityLevel(msg['severity'])) && 
        this['summary'] === msg['summary'] && 
        this['detail'] === msg['detail'])
    {
      return true;
    }
  }
  
  return false;
};

/**
 * Returns an Object that is a clone of this message. 
 * 
 * @return {Object} instance of oj.Message
 * @export
 * @memberof oj.Message
 * @since 0.7
 */
oj.Message.prototype.clone = function ()
{
  return new oj.Message(this['summary'], this['detail'], this['severity']);
};

/**
 * A convenience method that returns the severity level when given either a severity level of type 
 * number or a severity type of string. 
 * If severity level is not provided or is not valid this returns a severity error.
 * @param {string|number|undefined} severity 
 * @return {number}
 * @export
 */
oj.Message.getSeverityLevel = function (severity)
{
  var index;
  if (severity)
  {
    if (typeof severity === "string")
    {
      index = oj.Message._LEVEL_TO_TYPE.indexOf(severity, 1);
      if (index === -1)
      {
        severity = oj.Message.SEVERITY_LEVEL['ERROR'];
      }
      else
      {
        severity = index;
      }
    }
    else if (typeof severity === "number" && (severity < oj.Message.SEVERITY_LEVEL['CONFIRMATION'] && 
          severity > oj.Message.SEVERITY_LEVEL['FATAL']))
    {
      severity = oj.Message.SEVERITY_LEVEL['ERROR'];
    }
  }
  
  return !severity ? oj.Message.SEVERITY_LEVEL['ERROR'] : severity;
};

/**
 * A convenience method that returns the severity type when given either a severity level of type 
 * number or a severity type of string. 
 * If severity level is not provided or is not valid this return a severity error.
 * @param {string|number|undefined} level 
 * @return {string}
 * @export
 */
oj.Message.getSeverityType = function (level) 
{
  var index;
  if (level)
  {
    if (typeof level === "string")
    {
      index = oj.Message._LEVEL_TO_TYPE.indexOf(level, 1);
      if (index === -1)
      {
        // when given an unrecognized type return "error"
        level = oj.Message.SEVERITY_TYPE['ERROR'];
      }
    }
    else if (typeof level === "number")
    {
      if (level < oj.Message.SEVERITY_LEVEL['CONFIRMATION'] && 
          level > oj.Message.SEVERITY_LEVEL['FATAL'])
      {
        level = oj.Message.SEVERITY_TYPE['ERROR'];
      }
      else
      {
        level = oj.Message._LEVEL_TO_TYPE[level];
      }
    }
  }
  return level || oj.Message.SEVERITY_TYPE['ERROR'];
};

/**
 * Returns the max severity level in a array of message objects. 
 * 
 * @param {Array} messages an array of message instances
 * @returns {number} -1 if none can be determined; otherwise a severity level as defined by 
 * oj.Message.SEVERITY_LEVEL.
 * @export
 */
oj.Message.getMaxSeverity = function (messages)
{
  var maxLevel = -1, currLevel, message, i;
  if (messages && messages.length > 0)
  {
    $.each(messages, function (i, message)
      {
        if (message)
        {
          currLevel = oj.Message.getSeverityLevel(message['severity']);
        }
        maxLevel = maxLevel < currLevel ? currLevel : maxLevel;
      });
    
  }
  
  return maxLevel;
};

/**
 * Returns false if messages are of severity error or greater.
 * 
 * @param {Array} messages an array of message instances
 * @returns {boolean} true if none of the messages are of severity error or greater. false otherwise
 * @export
 */
oj.Message.isValid = function (messages)
{
  var maxSeverity = oj.Message.getMaxSeverity(messages);
  if (maxSeverity >= oj.Message.SEVERITY_LEVEL.ERROR)
  {
    return false;
  }
  
  return true;
};

/**
 * @private
 * @type Array
 */
oj.Message._LEVEL_TO_TYPE = ['none', // this can never be set
                             oj.Message.SEVERITY_TYPE['CONFIRMATION'], 
                             oj.Message.SEVERITY_TYPE['INFO'],
                             oj.Message.SEVERITY_TYPE['WARNING'],
                             oj.Message.SEVERITY_TYPE['ERROR'],
                             oj.Message.SEVERITY_TYPE['FATAL']];