cloudmersive-phishing-detection-api-client 2.2.2 → 2.2.4

data/lib/cloudmersive-phishing-detection-api-client/models/phishing_detection_advanced_request.rb

@@ -18,18 +18,36 @@ module CloudmersivePhishingDetectionApiClient
     # Input text string to detect phishing against
     attr_accessor :input_string
 
+    # Optional: Type of text being analyzed. Must be one of: \"TextMessage\", \"UserMessage\", \"SalesLead\", \"EmailMessage\", \"SupportCase\", \"AppMessage\", \"Other\".
+    attr_accessor :text_type
+
     # Optional: Specify which AI model to use.  Possible choices are Normal and Advanced.  Default is Advanced.
     attr_accessor :model
 
+    # Optional: True if unsolicited sales should be allowed, false otherwise. Defaults to true.
+    attr_accessor :allow_unsolicited_sales
+
+    # Optional: True if promotional content should be allowed, false otherwise. Defaults to true.
+    attr_accessor :allow_promotional_content
+
+    # Optional: True if web URLs should be allowed in the input text, false otherwise. Defaults to true. When false, input containing URLs (including homoglyph URLs and spaced-out URLs) will be flagged as not clean.
+    attr_accessor :allow_web_urls
+
+    # Optional: True if phone numbers should be allowed in the input text, false otherwise. Defaults to true. When false, input containing phone numbers (including homoglyph digits and spaced-out or spelled-out workarounds) will be flagged as not clean.
+    attr_accessor :allow_phone_numbers
+
+    # Optional: True if email addresses should be allowed in the input text, false otherwise. Defaults to true. When false, input containing email addresses (including homoglyph characters and obfuscated workarounds like \"danny at somedomaine [DOT] com\") will be flagged as not clean.
+    attr_accessor :allow_email_addresses
+
+    # Optional: True to perform deep URL analysis on any URLs detected in the text. When enabled, if the initial AI scan detects URLs, a second AI call enumerates them and each URL is individually analyzed for phishing. Defaults to true.
+    attr_accessor :provide_url_analysis
+
     # Apply a Custom Policy for Phishing Enforcement by providing the ID; to create a Custom Policy,  navigate to the Cloudmersive Management Portal and select Custom Policies.  Requires Managed Instance or Private Cloud
     attr_accessor :custom_policy_id
 
     # Optional: Set to true to include an analysis rationale in the response explaining why the content was or was not flagged.  Default is true.
     attr_accessor :provide_analysis_rationale
 
-    # Optional: Type of text being analyzed. Must be one of: \"Text Message\", \"User Message\", \"Sales Lead\", \"Email Message\", \"Support Case\", \"Other\".
-    attr_accessor :text_type
-
     # Optional: Name of the sender
     attr_accessor :from_name
 
@@ -48,20 +66,30 @@ module CloudmersivePhishingDetectionApiClient
     # Optional: Email address of the recipient
     attr_accessor :to_email_address
 
+    # Optional: Prior context history (e.g. message history) leading up to the current input string. If provided, the AI will take this history into account as context when evaluating the current input.
+    attr_accessor :prior_history
+
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         :'input_string' => :'InputString',
+        :'text_type' => :'TextType',
         :'model' => :'Model',
+        :'allow_unsolicited_sales' => :'AllowUnsolicitedSales',
+        :'allow_promotional_content' => :'AllowPromotionalContent',
+        :'allow_web_urls' => :'AllowWebUrls',
+        :'allow_phone_numbers' => :'AllowPhoneNumbers',
+        :'allow_email_addresses' => :'AllowEmailAddresses',
+        :'provide_url_analysis' => :'ProvideUrlAnalysis',
         :'custom_policy_id' => :'CustomPolicyID',
         :'provide_analysis_rationale' => :'ProvideAnalysisRationale',
-        :'text_type' => :'TextType',
         :'from_name' => :'FromName',
         :'to_name' => :'ToName',
         :'from_phone_number' => :'FromPhoneNumber',
         :'to_phone_number' => :'ToPhoneNumber',
         :'from_email_address' => :'FromEmailAddress',
-        :'to_email_address' => :'ToEmailAddress'
+        :'to_email_address' => :'ToEmailAddress',
+        :'prior_history' => :'PriorHistory'
       }
     end
 
@@ -69,16 +97,23 @@ module CloudmersivePhishingDetectionApiClient
     def self.swagger_types
       {
         :'input_string' => :'String',
+        :'text_type' => :'String',
         :'model' => :'String',
+        :'allow_unsolicited_sales' => :'BOOLEAN',
+        :'allow_promotional_content' => :'BOOLEAN',
+        :'allow_web_urls' => :'BOOLEAN',
+        :'allow_phone_numbers' => :'BOOLEAN',
+        :'allow_email_addresses' => :'BOOLEAN',
+        :'provide_url_analysis' => :'BOOLEAN',
         :'custom_policy_id' => :'String',
         :'provide_analysis_rationale' => :'BOOLEAN',
-        :'text_type' => :'String',
         :'from_name' => :'String',
         :'to_name' => :'String',
         :'from_phone_number' => :'String',
         :'to_phone_number' => :'String',
         :'from_email_address' => :'String',
-        :'to_email_address' => :'String'
+        :'to_email_address' => :'String',
+        :'prior_history' => :'Array<PriorHistoryItem>'
       }
     end
 
@@ -94,10 +129,38 @@ module CloudmersivePhishingDetectionApiClient
         self.input_string = attributes[:'InputString']
       end
 
+      if attributes.has_key?(:'TextType')
+        self.text_type = attributes[:'TextType']
+      end
+
       if attributes.has_key?(:'Model')
         self.model = attributes[:'Model']
       end
 
+      if attributes.has_key?(:'AllowUnsolicitedSales')
+        self.allow_unsolicited_sales = attributes[:'AllowUnsolicitedSales']
+      end
+
+      if attributes.has_key?(:'AllowPromotionalContent')
+        self.allow_promotional_content = attributes[:'AllowPromotionalContent']
+      end
+
+      if attributes.has_key?(:'AllowWebUrls')
+        self.allow_web_urls = attributes[:'AllowWebUrls']
+      end
+
+      if attributes.has_key?(:'AllowPhoneNumbers')
+        self.allow_phone_numbers = attributes[:'AllowPhoneNumbers']
+      end
+
+      if attributes.has_key?(:'AllowEmailAddresses')
+        self.allow_email_addresses = attributes[:'AllowEmailAddresses']
+      end
+
+      if attributes.has_key?(:'ProvideUrlAnalysis')
+        self.provide_url_analysis = attributes[:'ProvideUrlAnalysis']
+      end
+
       if attributes.has_key?(:'CustomPolicyID')
         self.custom_policy_id = attributes[:'CustomPolicyID']
       end
@@ -106,10 +169,6 @@ module CloudmersivePhishingDetectionApiClient
         self.provide_analysis_rationale = attributes[:'ProvideAnalysisRationale']
       end
 
-      if attributes.has_key?(:'TextType')
-        self.text_type = attributes[:'TextType']
-      end
-
       if attributes.has_key?(:'FromName')
         self.from_name = attributes[:'FromName']
       end
@@ -133,6 +192,12 @@ module CloudmersivePhishingDetectionApiClient
       if attributes.has_key?(:'ToEmailAddress')
         self.to_email_address = attributes[:'ToEmailAddress']
       end
+
+      if attributes.has_key?(:'PriorHistory')
+        if (value = attributes[:'PriorHistory']).is_a?(Array)
+          self.prior_history = value
+        end
+      end
     end
 
     # Show invalid properties with the reasons. Usually used together with valid?
@@ -154,16 +219,23 @@ module CloudmersivePhishingDetectionApiClient
       return true if self.equal?(o)
       self.class == o.class &&
           input_string == o.input_string &&
+          text_type == o.text_type &&
           model == o.model &&
+          allow_unsolicited_sales == o.allow_unsolicited_sales &&
+          allow_promotional_content == o.allow_promotional_content &&
+          allow_web_urls == o.allow_web_urls &&
+          allow_phone_numbers == o.allow_phone_numbers &&
+          allow_email_addresses == o.allow_email_addresses &&
+          provide_url_analysis == o.provide_url_analysis &&
           custom_policy_id == o.custom_policy_id &&
           provide_analysis_rationale == o.provide_analysis_rationale &&
-          text_type == o.text_type &&
           from_name == o.from_name &&
           to_name == o.to_name &&
           from_phone_number == o.from_phone_number &&
           to_phone_number == o.to_phone_number &&
           from_email_address == o.from_email_address &&
-          to_email_address == o.to_email_address
+          to_email_address == o.to_email_address &&
+          prior_history == o.prior_history
     end
 
     # @see the `==` method
@@ -175,7 +247,7 @@ module CloudmersivePhishingDetectionApiClient
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
-      [input_string, model, custom_policy_id, provide_analysis_rationale, text_type, from_name, to_name, from_phone_number, to_phone_number, from_email_address, to_email_address].hash
+      [input_string, text_type, model, allow_unsolicited_sales, allow_promotional_content, allow_web_urls, allow_phone_numbers, allow_email_addresses, provide_url_analysis, custom_policy_id, provide_analysis_rationale, from_name, to_name, from_phone_number, to_phone_number, from_email_address, to_email_address, prior_history].hash
     end
 
     # Builds the object from hash

data/lib/cloudmersive-phishing-detection-api-client/models/phishing_detection_advanced_response.rb

@@ -18,8 +18,23 @@ module CloudmersivePhishingDetectionApiClient
     # True if the result is not phishing (clean), and false otherwise
     attr_accessor :clean_result
 
-    # Overall phishing risk level between 0.0 and 1.0
-    attr_accessor :phishing_risk_level
+    # True if the input text contains a phishing attempt, false otherwise
+    attr_accessor :contains_phishing
+
+    # True if the input text contains unsolicited sales, false otherwise
+    attr_accessor :contains_unsolicited_sales
+
+    # True if the input text contains promotional content, false otherwise
+    attr_accessor :contains_promotional_content
+
+    # True if the input text contains web URLs, including homoglyph URLs and spaced-out URL workarounds
+    attr_accessor :contains_web_urls
+
+    # True if the input text contains phone numbers, including homoglyph digits and spaced-out or spelled-out workarounds
+    attr_accessor :contains_phone_numbers
+
+    # True if the input text contains email addresses, including homoglyph characters and obfuscated workarounds
+    attr_accessor :contains_email_addresses
 
     # Confidence level between 0.0 and 1.0 where values over 0.9 indicate high confidence
     attr_accessor :confidence_level
@@ -27,13 +42,22 @@ module CloudmersivePhishingDetectionApiClient
     # Rationale for why the conclusion was formed
     attr_accessor :analysis_rationale
 
+    # URLs detected in the input text that were analyzed and found to be unsafe. Only populated when ProvideUrlAnalysis is true and URLs are detected.
+    attr_accessor :unsafe_urls
+
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         :'clean_result' => :'CleanResult',
-        :'phishing_risk_level' => :'PhishingRiskLevel',
+        :'contains_phishing' => :'ContainsPhishing',
+        :'contains_unsolicited_sales' => :'ContainsUnsolicitedSales',
+        :'contains_promotional_content' => :'ContainsPromotionalContent',
+        :'contains_web_urls' => :'ContainsWebUrls',
+        :'contains_phone_numbers' => :'ContainsPhoneNumbers',
+        :'contains_email_addresses' => :'ContainsEmailAddresses',
         :'confidence_level' => :'ConfidenceLevel',
-        :'analysis_rationale' => :'AnalysisRationale'
+        :'analysis_rationale' => :'AnalysisRationale',
+        :'unsafe_urls' => :'UnsafeUrls'
       }
     end
 
@@ -41,9 +65,15 @@ module CloudmersivePhishingDetectionApiClient
     def self.swagger_types
       {
         :'clean_result' => :'BOOLEAN',
-        :'phishing_risk_level' => :'Float',
+        :'contains_phishing' => :'BOOLEAN',
+        :'contains_unsolicited_sales' => :'BOOLEAN',
+        :'contains_promotional_content' => :'BOOLEAN',
+        :'contains_web_urls' => :'BOOLEAN',
+        :'contains_phone_numbers' => :'BOOLEAN',
+        :'contains_email_addresses' => :'BOOLEAN',
         :'confidence_level' => :'Float',
-        :'analysis_rationale' => :'String'
+        :'analysis_rationale' => :'String',
+        :'unsafe_urls' => :'Array<UnsafeUrlResult>'
       }
     end
 
@@ -59,8 +89,28 @@ module CloudmersivePhishingDetectionApiClient
         self.clean_result = attributes[:'CleanResult']
       end
 
-      if attributes.has_key?(:'PhishingRiskLevel')
-        self.phishing_risk_level = attributes[:'PhishingRiskLevel']
+      if attributes.has_key?(:'ContainsPhishing')
+        self.contains_phishing = attributes[:'ContainsPhishing']
+      end
+
+      if attributes.has_key?(:'ContainsUnsolicitedSales')
+        self.contains_unsolicited_sales = attributes[:'ContainsUnsolicitedSales']
+      end
+
+      if attributes.has_key?(:'ContainsPromotionalContent')
+        self.contains_promotional_content = attributes[:'ContainsPromotionalContent']
+      end
+
+      if attributes.has_key?(:'ContainsWebUrls')
+        self.contains_web_urls = attributes[:'ContainsWebUrls']
+      end
+
+      if attributes.has_key?(:'ContainsPhoneNumbers')
+        self.contains_phone_numbers = attributes[:'ContainsPhoneNumbers']
+      end
+
+      if attributes.has_key?(:'ContainsEmailAddresses')
+        self.contains_email_addresses = attributes[:'ContainsEmailAddresses']
       end
 
       if attributes.has_key?(:'ConfidenceLevel')
@@ -70,6 +120,12 @@ module CloudmersivePhishingDetectionApiClient
       if attributes.has_key?(:'AnalysisRationale')
         self.analysis_rationale = attributes[:'AnalysisRationale']
       end
+
+      if attributes.has_key?(:'UnsafeUrls')
+        if (value = attributes[:'UnsafeUrls']).is_a?(Array)
+          self.unsafe_urls = value
+        end
+      end
     end
 
     # Show invalid properties with the reasons. Usually used together with valid?
@@ -91,9 +147,15 @@ module CloudmersivePhishingDetectionApiClient
       return true if self.equal?(o)
       self.class == o.class &&
           clean_result == o.clean_result &&
-          phishing_risk_level == o.phishing_risk_level &&
+          contains_phishing == o.contains_phishing &&
+          contains_unsolicited_sales == o.contains_unsolicited_sales &&
+          contains_promotional_content == o.contains_promotional_content &&
+          contains_web_urls == o.contains_web_urls &&
+          contains_phone_numbers == o.contains_phone_numbers &&
+          contains_email_addresses == o.contains_email_addresses &&
           confidence_level == o.confidence_level &&
-          analysis_rationale == o.analysis_rationale
+          analysis_rationale == o.analysis_rationale &&
+          unsafe_urls == o.unsafe_urls
     end
 
     # @see the `==` method
@@ -105,7 +167,7 @@ module CloudmersivePhishingDetectionApiClient
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
-      [clean_result, phishing_risk_level, confidence_level, analysis_rationale].hash
+      [clean_result, contains_phishing, contains_unsolicited_sales, contains_promotional_content, contains_web_urls, contains_phone_numbers, contains_email_addresses, confidence_level, analysis_rationale, unsafe_urls].hash
     end
 
     # Builds the object from hash

data/lib/cloudmersive-phishing-detection-api-client/models/phishing_detection_text_string_request.rb

@@ -0,0 +1,206 @@
+=begin
+#phishingapi
+
+#Easily and directly scan and block phishing security threats in input.
+
+OpenAPI spec version: v1
+
+Generated by: https://github.com/swagger-api/swagger-codegen.git
+Swagger Codegen version: 2.4.14
+
+=end
+
+require 'date'
+
+module CloudmersivePhishingDetectionApiClient
+  # AI phishing detection request for basic text string analysis
+  class PhishingDetectionTextStringRequest
+    # Input text string to detect phishing against
+    attr_accessor :input_string
+
+    # Optional: Specify which AI model to use.  Possible choices are Normal and Advanced.  Default is Advanced.
+    attr_accessor :model
+
+    # Optional: Set to true to include an analysis rationale in the response explaining why the content was or was not flagged.  Default is true.
+    attr_accessor :provide_analysis_rationale
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'input_string' => :'InputString',
+        :'model' => :'Model',
+        :'provide_analysis_rationale' => :'ProvideAnalysisRationale'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        :'input_string' => :'String',
+        :'model' => :'String',
+        :'provide_analysis_rationale' => :'BOOLEAN'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'InputString')
+        self.input_string = attributes[:'InputString']
+      end
+
+      if attributes.has_key?(:'Model')
+        self.model = attributes[:'Model']
+      end
+
+      if attributes.has_key?(:'ProvideAnalysisRationale')
+        self.provide_analysis_rationale = attributes[:'ProvideAnalysisRationale']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          input_string == o.input_string &&
+          model == o.model &&
+          provide_analysis_rationale == o.provide_analysis_rationale
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [input_string, model, provide_analysis_rationale].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = CloudmersivePhishingDetectionApiClient.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+end