trycourier 2.0.0 → 3.0.0.pre.beta1

data/lib/trycourier/send/types/preference.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "../../commons/types/preference_status"
+require_relative "../../commons/types/rule"
+require_relative "../../commons/types/channel_preference"
+require_relative "channel_source"
+require "json"
+
+module Courier
+  class Send
+    class Preference
+      attr_reader :status, :rules, :channel_preferences, :source, :additional_properties
+
+      # @param status [Commons::PreferenceStatus]
+      # @param rules [Array<Commons::Rule>]
+      # @param channel_preferences [Array<Commons::ChannelPreference>]
+      # @param source [Send::ChannelSource]
+      # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+      # @return [Send::Preference]
+      def initialize(status:, rules: nil, channel_preferences: nil, source: nil, additional_properties: nil)
+        # @type [Commons::PreferenceStatus]
+        @status = status
+        # @type [Array<Commons::Rule>]
+        @rules = rules
+        # @type [Array<Commons::ChannelPreference>]
+        @channel_preferences = channel_preferences
+        # @type [Send::ChannelSource]
+        @source = source
+        # @type [OpenStruct] Additional properties unmapped to the current class definition
+        @additional_properties = additional_properties
+      end
+
+      # Deserialize a JSON object to an instance of Preference
+      #
+      # @param json_object [JSON]
+      # @return [Send::Preference]
+      def self.from_json(json_object:)
+        struct = JSON.parse(json_object, object_class: OpenStruct)
+        parsed_json = JSON.parse(json_object)
+        status = struct.status
+        rules = parsed_json["rules"]&.map do |v|
+          v = v.to_json
+          Commons::Rule.from_json(json_object: v)
+        end
+        channel_preferences = parsed_json["channel_preferences"]&.map do |v|
+          v = v.to_json
+          Commons::ChannelPreference.from_json(json_object: v)
+        end
+        source = struct.source
+        new(status: status, rules: rules, channel_preferences: channel_preferences, source: source,
+            additional_properties: struct)
+      end
+
+      # Serialize an instance of Preference to a JSON object
+      #
+      # @return [JSON]
+      def to_json(*_args)
+        { "status": @status, "rules": @rules, "channel_preferences": @channel_preferences, "source": @source }.to_json
+      end
+
+      # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+      #
+      # @param obj [Object]
+      # @return [Void]
+      def self.validate_raw(obj:)
+        obj.status.is_a?(Commons::PreferenceStatus) != false || raise("Passed value for field obj.status is not the expected type, validation failed.")
+        obj.rules&.is_a?(Array) != false || raise("Passed value for field obj.rules is not the expected type, validation failed.")
+        obj.channel_preferences&.is_a?(Array) != false || raise("Passed value for field obj.channel_preferences is not the expected type, validation failed.")
+        obj.source&.is_a?(Send::ChannelSource) != false || raise("Passed value for field obj.source is not the expected type, validation failed.")
+      end
+    end
+  end
+end

data/lib/trycourier/send/types/preferences.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Courier
+  class Send
+    class Preferences
+      attr_reader :template_ids, :additional_properties
+
+      # @param template_ids [Array<String>]
+      # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+      # @return [Send::Preferences]
+      def initialize(template_ids:, additional_properties: nil)
+        # @type [Array<String>]
+        @template_ids = template_ids
+        # @type [OpenStruct] Additional properties unmapped to the current class definition
+        @additional_properties = additional_properties
+      end
+
+      # Deserialize a JSON object to an instance of Preferences
+      #
+      # @param json_object [JSON]
+      # @return [Send::Preferences]
+      def self.from_json(json_object:)
+        struct = JSON.parse(json_object, object_class: OpenStruct)
+        JSON.parse(json_object)
+        template_ids = struct.templateIds
+        new(template_ids: template_ids, additional_properties: struct)
+      end
+
+      # Serialize an instance of Preferences to a JSON object
+      #
+      # @return [JSON]
+      def to_json(*_args)
+        { "templateIds": @template_ids }.to_json
+      end
+
+      # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+      #
+      # @param obj [Object]
+      # @return [Void]
+      def self.validate_raw(obj:)
+        obj.template_ids.is_a?(Array) != false || raise("Passed value for field obj.template_ids is not the expected type, validation failed.")
+      end
+    end
+  end
+end

data/lib/trycourier/send/types/recipient.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "audience_recipient"
+require_relative "list_recipient"
+require_relative "list_pattern_recipient"
+require_relative "user_recipient"
+require_relative "slack_recipient"
+require_relative "ms_teams_recipient"
+
+module Courier
+  class Send
+    class Recipient
+      # Deserialize a JSON object to an instance of Recipient
+      #
+      # @param json_object [JSON]
+      # @return [Send::Recipient]
+      def self.from_json(json_object:)
+        struct = JSON.parse(json_object, object_class: OpenStruct)
+        begin
+          Send::AudienceRecipient.validate_raw(obj: struct)
+          return Send::AudienceRecipient.from_json(json_object: json_object)
+        rescue StandardError
+          # noop
+        end
+        begin
+          Send::ListRecipient.validate_raw(obj: struct)
+          return Send::ListRecipient.from_json(json_object: json_object)
+        rescue StandardError
+          # noop
+        end
+        begin
+          Send::ListPatternRecipient.validate_raw(obj: struct)
+          return Send::ListPatternRecipient.from_json(json_object: json_object)
+        rescue StandardError
+          # noop
+        end
+        begin
+          Send::UserRecipient.validate_raw(obj: struct)
+          return Send::UserRecipient.from_json(json_object: json_object)
+        rescue StandardError
+          # noop
+        end
+        begin
+          Send::SlackRecipient.validate_raw(obj: struct)
+          return Send::SlackRecipient.from_json(json_object: json_object)
+        rescue StandardError
+          # noop
+        end
+        begin
+          Send::MsTeamsRecipient.validate_raw(obj: struct)
+          return Send::MsTeamsRecipient.from_json(json_object: json_object)
+        rescue StandardError
+          # noop
+        end
+        struct
+      end
+
+      # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+      #
+      # @param obj [Object]
+      # @return [Void]
+      def self.validate_raw(obj:)
+        begin
+          return Send::AudienceRecipient.validate_raw(obj: obj)
+        rescue StandardError
+          # noop
+        end
+        begin
+          return Send::ListRecipient.validate_raw(obj: obj)
+        rescue StandardError
+          # noop
+        end
+        begin
+          return Send::ListPatternRecipient.validate_raw(obj: obj)
+        rescue StandardError
+          # noop
+        end
+        begin
+          return Send::UserRecipient.validate_raw(obj: obj)
+        rescue StandardError
+          # noop
+        end
+        begin
+          return Send::SlackRecipient.validate_raw(obj: obj)
+        rescue StandardError
+          # noop
+        end
+        begin
+          return Send::MsTeamsRecipient.validate_raw(obj: obj)
+        rescue StandardError
+          # noop
+        end
+        raise("Passed value matched no type within the union, validation failed.")
+      end
+    end
+  end
+end

data/lib/trycourier/send/types/routing.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "routing_method"
+require_relative "routing_channel"
+require "json"
+
+module Courier
+  class Send
+    # Allows you to customize which channel(s) Courier will potentially deliver the message.
+    # If no routing key is specified, Courier will use the default routing configuration or
+    # routing defined by the template.
+    class Routing
+      attr_reader :method, :channels, :additional_properties
+
+      # @param method [Send::RoutingMethod]
+      # @param channels [Array<Send::RoutingChannel>] A list of channels or providers to send the message through. Can also recursively define
+      #   sub-routing methods, which can be useful for defining advanced push notification
+      #   delivery strategies.
+      # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+      # @return [Send::Routing]
+      def initialize(method:, channels:, additional_properties: nil)
+        # @type [Send::RoutingMethod]
+        @method = method
+        # @type [Array<Send::RoutingChannel>] A list of channels or providers to send the message through. Can also recursively define
+        #   sub-routing methods, which can be useful for defining advanced push notification
+        #   delivery strategies.
+        @channels = channels
+        # @type [OpenStruct] Additional properties unmapped to the current class definition
+        @additional_properties = additional_properties
+      end
+
+      # Deserialize a JSON object to an instance of Routing
+      #
+      # @param json_object [JSON]
+      # @return [Send::Routing]
+      def self.from_json(json_object:)
+        struct = JSON.parse(json_object, object_class: OpenStruct)
+        parsed_json = JSON.parse(json_object)
+        method = struct.method
+        channels = parsed_json["channels"]&.map do |v|
+          v = v.to_json
+          Send::RoutingChannel.from_json(json_object: v)
+        end
+        new(method: method, channels: channels, additional_properties: struct)
+      end
+
+      # Serialize an instance of Routing to a JSON object
+      #
+      # @return [JSON]
+      def to_json(*_args)
+        { "method": @method, "channels": @channels }.to_json
+      end
+
+      # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+      #
+      # @param obj [Object]
+      # @return [Void]
+      def self.validate_raw(obj:)
+        obj.method.is_a?(Send::RoutingMethod) != false || raise("Passed value for field obj.method is not the expected type, validation failed.")
+        obj.channels.is_a?(Array) != false || raise("Passed value for field obj.channels is not the expected type, validation failed.")
+      end
+    end
+  end
+end

data/lib/trycourier/send/types/routing_channel.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "routing_strategy_channel"
+require_relative "routing_strategy_provider"
+
+module Courier
+  class Send
+    class RoutingChannel
+      # Deserialize a JSON object to an instance of RoutingChannel
+      #
+      # @param json_object [JSON]
+      # @return [Send::RoutingChannel]
+      def self.from_json(json_object:)
+        struct = JSON.parse(json_object, object_class: OpenStruct)
+        begin
+          Send::RoutingStrategyChannel.validate_raw(obj: struct)
+          return Send::RoutingStrategyChannel.from_json(json_object: json_object)
+        rescue StandardError
+          # noop
+        end
+        begin
+          Send::RoutingStrategyProvider.validate_raw(obj: struct)
+          return Send::RoutingStrategyProvider.from_json(json_object: json_object)
+        rescue StandardError
+          # noop
+        end
+        begin
+          struct.is_a?(String) != false || raise("Passed value for field struct is not the expected type, validation failed.")
+          return json_object
+        rescue StandardError
+          # noop
+        end
+        struct
+      end
+
+      # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+      #
+      # @param obj [Object]
+      # @return [Void]
+      def self.validate_raw(obj:)
+        begin
+          return Send::RoutingStrategyChannel.validate_raw(obj: obj)
+        rescue StandardError
+          # noop
+        end
+        begin
+          return Send::RoutingStrategyProvider.validate_raw(obj: obj)
+        rescue StandardError
+          # noop
+        end
+        begin
+          return obj.is_a?(String) != false || raise("Passed value for field obj is not the expected type, validation failed.")
+        rescue StandardError
+          # noop
+        end
+        raise("Passed value matched no type within the union, validation failed.")
+      end
+    end
+  end
+end

data/lib/trycourier/send/types/routing_method.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Courier
+  class Send
+    class RoutingMethod
+      ALL = "all"
+      SINGLE = "single"
+    end
+  end
+end

data/lib/trycourier/send/types/routing_strategy_channel.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "routing_method"
+require_relative "message_providers"
+require "json"
+
+module Courier
+  class Send
+    class RoutingStrategyChannel
+      attr_reader :channel, :config, :method, :providers, :if_, :additional_properties
+
+      # @param channel [String]
+      # @param config [Hash{String => String}]
+      # @param method [Send::RoutingMethod]
+      # @param providers [Send::MESSAGE_PROVIDERS]
+      # @param if_ [String]
+      # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+      # @return [Send::RoutingStrategyChannel]
+      def initialize(channel:, config: nil, method: nil, providers: nil, if_: nil, additional_properties: nil)
+        # @type [String]
+        @channel = channel
+        # @type [Hash{String => String}]
+        @config = config
+        # @type [Send::RoutingMethod]
+        @method = method
+        # @type [Send::MESSAGE_PROVIDERS]
+        @providers = providers
+        # @type [String]
+        @if_ = if_
+        # @type [OpenStruct] Additional properties unmapped to the current class definition
+        @additional_properties = additional_properties
+      end
+
+      # Deserialize a JSON object to an instance of RoutingStrategyChannel
+      #
+      # @param json_object [JSON]
+      # @return [Send::RoutingStrategyChannel]
+      def self.from_json(json_object:)
+        struct = JSON.parse(json_object, object_class: OpenStruct)
+        JSON.parse(json_object)
+        channel = struct.channel
+        config = struct.config
+        method = struct.method
+        providers = struct.providers
+        if_ = struct.if
+        new(channel: channel, config: config, method: method, providers: providers, if_: if_,
+            additional_properties: struct)
+      end
+
+      # Serialize an instance of RoutingStrategyChannel to a JSON object
+      #
+      # @return [JSON]
+      def to_json(*_args)
+        { "channel": @channel, "config": @config, "method": @method, "providers": @providers, "if": @if_ }.to_json
+      end
+
+      # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+      #
+      # @param obj [Object]
+      # @return [Void]
+      def self.validate_raw(obj:)
+        obj.channel.is_a?(String) != false || raise("Passed value for field obj.channel is not the expected type, validation failed.")
+        obj.config&.is_a?(Hash) != false || raise("Passed value for field obj.config is not the expected type, validation failed.")
+        obj.method&.is_a?(Send::RoutingMethod) != false || raise("Passed value for field obj.method is not the expected type, validation failed.")
+        obj.providers&.is_a?(Hash) != false || raise("Passed value for field obj.providers is not the expected type, validation failed.")
+        obj.if_&.is_a?(String) != false || raise("Passed value for field obj.if_ is not the expected type, validation failed.")
+      end
+    end
+  end
+end

data/lib/trycourier/send/types/routing_strategy_provider.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "metadata"
+require "json"
+
+module Courier
+  class Send
+    class RoutingStrategyProvider
+      attr_reader :name, :config, :if_, :metadata, :additional_properties
+
+      # @param name [String]
+      # @param config [Hash{String => String}]
+      # @param if_ [String]
+      # @param metadata [Send::Metadata]
+      # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+      # @return [Send::RoutingStrategyProvider]
+      def initialize(name:, metadata:, config: nil, if_: nil, additional_properties: nil)
+        # @type [String]
+        @name = name
+        # @type [Hash{String => String}]
+        @config = config
+        # @type [String]
+        @if_ = if_
+        # @type [Send::Metadata]
+        @metadata = metadata
+        # @type [OpenStruct] Additional properties unmapped to the current class definition
+        @additional_properties = additional_properties
+      end
+
+      # Deserialize a JSON object to an instance of RoutingStrategyProvider
+      #
+      # @param json_object [JSON]
+      # @return [Send::RoutingStrategyProvider]
+      def self.from_json(json_object:)
+        struct = JSON.parse(json_object, object_class: OpenStruct)
+        parsed_json = JSON.parse(json_object)
+        name = struct.name
+        config = struct.config
+        if_ = struct.if
+        if parsed_json["metadata"].nil?
+          metadata = nil
+        else
+          metadata = parsed_json["metadata"].to_json
+          metadata = Send::Metadata.from_json(json_object: metadata)
+        end
+        new(name: name, config: config, if_: if_, metadata: metadata, additional_properties: struct)
+      end
+
+      # Serialize an instance of RoutingStrategyProvider to a JSON object
+      #
+      # @return [JSON]
+      def to_json(*_args)
+        { "name": @name, "config": @config, "if": @if_, "metadata": @metadata }.to_json
+      end
+
+      # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+      #
+      # @param obj [Object]
+      # @return [Void]
+      def self.validate_raw(obj:)
+        obj.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+        obj.config&.is_a?(Hash) != false || raise("Passed value for field obj.config is not the expected type, validation failed.")
+        obj.if_&.is_a?(String) != false || raise("Passed value for field obj.if_ is not the expected type, validation failed.")
+        Send::Metadata.validate_raw(obj: obj.metadata)
+      end
+    end
+  end
+end

data/lib/trycourier/send/types/rule_type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Courier
+  class Send
+    class RuleType
+      SNOOZE = "snooze"
+      CHANNEL_PREFERENCES = "channel_preferences"
+      STATUS = "status"
+    end
+  end
+end

data/lib/trycourier/send/types/slack_recipient.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../../profiles/types/slack"
+require "json"
+
+module Courier
+  class Send
+    class SlackRecipient
+      attr_reader :slack, :additional_properties
+
+      # @param slack [Profiles::Slack]
+      # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+      # @return [Send::SlackRecipient]
+      def initialize(slack:, additional_properties: nil)
+        # @type [Profiles::Slack]
+        @slack = slack
+        # @type [OpenStruct] Additional properties unmapped to the current class definition
+        @additional_properties = additional_properties
+      end
+
+      # Deserialize a JSON object to an instance of SlackRecipient
+      #
+      # @param json_object [JSON]
+      # @return [Send::SlackRecipient]
+      def self.from_json(json_object:)
+        struct = JSON.parse(json_object, object_class: OpenStruct)
+        parsed_json = JSON.parse(json_object)
+        if parsed_json["slack"].nil?
+          slack = nil
+        else
+          slack = parsed_json["slack"].to_json
+          slack = Profiles::Slack.from_json(json_object: slack)
+        end
+        new(slack: slack, additional_properties: struct)
+      end
+
+      # Serialize an instance of SlackRecipient to a JSON object
+      #
+      # @return [JSON]
+      def to_json(*_args)
+        { "slack": @slack }.to_json
+      end
+
+      # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+      #
+      # @param obj [Object]
+      # @return [Void]
+      def self.validate_raw(obj:)
+        Profiles::Slack.validate_raw(obj: obj.slack)
+      end
+    end
+  end
+end