license_manager 0.1.1 → 0.3.0

data/lib/license_manager/models/revenue.rb

@@ -14,17 +14,29 @@ require 'date'
 require 'time'
 
 module LicenseManager
-  # Revenue of the licenses sold in one currency, each license counting on the day it was created. Licenses without a price are left out.
+  # Revenue in one currency: the licenses sold once, each counting on the day it was created, and the payments of the subscription licenses, each counting on the day it was paid, with the license's policy. Licenses without a price are left out, and so are canceled ones, but in `canceledLicenseCount` and `canceledTotal`.
   class Revenue < ApiModelBase
     # ISO 4217 code of the currency of the revenue.
     attr_accessor :currency
 
-    # Number of licenses sold in the currency, free ones included.
+    # Number of licenses sold once in the currency, free ones included, canceled ones and subscription licenses left out.
     attr_accessor :license_count
 
-    # Sum of the prices of the licenses sold in the currency, in major units.
+    # Revenue in the currency, in major units: the prices of the licenses sold once, canceled ones left out, plus the payments of the subscriptions, `subscriptionTotal`.
     attr_accessor :total
 
+    # Sum of the payments of the subscription licenses in the currency, before taxes, in major units.
+    attr_accessor :subscription_total
+
+    # Number of payments of the subscription licenses in the currency.
+    attr_accessor :payment_count
+
+    # Number of canceled licenses sold once in the currency.
+    attr_accessor :canceled_license_count
+
+    # Sum of the prices of the canceled licenses sold once in the currency, in major units: revenue lost to cancellations.
+    attr_accessor :canceled_total
+
     # Revenue of the current month, in UTC.
     attr_accessor :this_month
 
@@ -49,6 +61,10 @@ module LicenseManager
         :'currency' => :'currency',
         :'license_count' => :'licenseCount',
         :'total' => :'total',
+        :'subscription_total' => :'subscriptionTotal',
+        :'payment_count' => :'paymentCount',
+        :'canceled_license_count' => :'canceledLicenseCount',
+        :'canceled_total' => :'canceledTotal',
         :'this_month' => :'thisMonth',
         :'last_month' => :'lastMonth',
         :'last30_days' => :'last30Days',
@@ -74,6 +90,10 @@ module LicenseManager
         :'currency' => :'String',
         :'license_count' => :'Integer',
         :'total' => :'Float',
+        :'subscription_total' => :'Float',
+        :'payment_count' => :'Integer',
+        :'canceled_license_count' => :'Integer',
+        :'canceled_total' => :'Float',
         :'this_month' => :'Float',
         :'last_month' => :'Float',
         :'last30_days' => :'Float',
@@ -133,6 +153,30 @@ module LicenseManager
         self.total = nil
       end
 
+      if attributes.key?(:'subscription_total')
+        self.subscription_total = attributes[:'subscription_total']
+      else
+        self.subscription_total = nil
+      end
+
+      if attributes.key?(:'payment_count')
+        self.payment_count = attributes[:'payment_count']
+      else
+        self.payment_count = nil
+      end
+
+      if attributes.key?(:'canceled_license_count')
+        self.canceled_license_count = attributes[:'canceled_license_count']
+      else
+        self.canceled_license_count = nil
+      end
+
+      if attributes.key?(:'canceled_total')
+        self.canceled_total = attributes[:'canceled_total']
+      else
+        self.canceled_total = nil
+      end
+
       if attributes.key?(:'this_month')
         self.this_month = attributes[:'this_month']
       else
@@ -193,6 +237,22 @@ module LicenseManager
         invalid_properties.push('invalid value for "total", total cannot be nil.')
       end
 
+      if @subscription_total.nil?
+        invalid_properties.push('invalid value for "subscription_total", subscription_total cannot be nil.')
+      end
+
+      if @payment_count.nil?
+        invalid_properties.push('invalid value for "payment_count", payment_count cannot be nil.')
+      end
+
+      if @canceled_license_count.nil?
+        invalid_properties.push('invalid value for "canceled_license_count", canceled_license_count cannot be nil.')
+      end
+
+      if @canceled_total.nil?
+        invalid_properties.push('invalid value for "canceled_total", canceled_total cannot be nil.')
+      end
+
       if @this_month.nil?
         invalid_properties.push('invalid value for "this_month", this_month cannot be nil.')
       end
@@ -227,6 +287,10 @@ module LicenseManager
       return false if @currency.nil?
       return false if @license_count.nil?
       return false if @total.nil?
+      return false if @subscription_total.nil?
+      return false if @payment_count.nil?
+      return false if @canceled_license_count.nil?
+      return false if @canceled_total.nil?
       return false if @this_month.nil?
       return false if @last_month.nil?
       return false if @last30_days.nil?
@@ -266,6 +330,46 @@ module LicenseManager
       @total = total
     end
 
+    # Custom attribute writer method with validation
+    # @param [Object] subscription_total Value to be assigned
+    def subscription_total=(subscription_total)
+      if subscription_total.nil?
+        fail ArgumentError, 'subscription_total cannot be nil'
+      end
+
+      @subscription_total = subscription_total
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] payment_count Value to be assigned
+    def payment_count=(payment_count)
+      if payment_count.nil?
+        fail ArgumentError, 'payment_count cannot be nil'
+      end
+
+      @payment_count = payment_count
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] canceled_license_count Value to be assigned
+    def canceled_license_count=(canceled_license_count)
+      if canceled_license_count.nil?
+        fail ArgumentError, 'canceled_license_count cannot be nil'
+      end
+
+      @canceled_license_count = canceled_license_count
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] canceled_total Value to be assigned
+    def canceled_total=(canceled_total)
+      if canceled_total.nil?
+        fail ArgumentError, 'canceled_total cannot be nil'
+      end
+
+      @canceled_total = canceled_total
+    end
+
     # Custom attribute writer method with validation
     # @param [Object] this_month Value to be assigned
     def this_month=(this_month)
@@ -334,6 +438,10 @@ module LicenseManager
           currency == o.currency &&
           license_count == o.license_count &&
           total == o.total &&
+          subscription_total == o.subscription_total &&
+          payment_count == o.payment_count &&
+          canceled_license_count == o.canceled_license_count &&
+          canceled_total == o.canceled_total &&
           this_month == o.this_month &&
           last_month == o.last_month &&
           last30_days == o.last30_days &&
@@ -351,7 +459,7 @@ module LicenseManager
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [currency, license_count, total, this_month, last_month, last30_days, by_day, by_month, by_policy].hash
+      [currency, license_count, total, subscription_total, payment_count, canceled_license_count, canceled_total, this_month, last_month, last30_days, by_day, by_month, by_policy].hash
     end
 
     # Builds the object from hash

data/lib/license_manager/models/stripe_integration.rb

@@ -21,7 +21,7 @@ module LicenseManager
     # Whether Stripe can reach the API's webhook URL. A local URL can't be: set `WEBHOOK_URL` on the server, like to a tunnel in development.
     attr_accessor :webhook_url_reachable
 
-    # Permissions the restricted API key needs, and why. Every other permission can stay `None`.
+    # Permissions the restricted API key needs, and why, the `optional` ones included. Every other permission can stay `None`.
     attr_accessor :required_permissions
 
     # The organization's Stripe connection in this mode, `null` when there's none.

data/lib/license_manager/models/stripe_permission.rb

@@ -21,6 +21,12 @@ module LicenseManager
 
     attr_accessor :reason
 
+    # Whether the key can connect without it, losing what it's for, explained by `reason`.
+    attr_accessor :optional
+
+    # Whether it's only needed to sell subscriptions: checked once a recurring price is mapped.
+    attr_accessor :subscriptions
+
     class EnumAttributeValidator
       attr_reader :datatype
       attr_reader :allowable_values
@@ -48,7 +54,9 @@ module LicenseManager
       {
         :'resource' => :'resource',
         :'access' => :'access',
-        :'reason' => :'reason'
+        :'reason' => :'reason',
+        :'optional' => :'optional',
+        :'subscriptions' => :'subscriptions'
       }
     end
 
@@ -67,7 +75,9 @@ module LicenseManager
       {
         :'resource' => :'String',
         :'access' => :'String',
-        :'reason' => :'String'
+        :'reason' => :'String',
+        :'optional' => :'Boolean',
+        :'subscriptions' => :'Boolean'
       }
     end
 
@@ -120,6 +130,18 @@ module LicenseManager
       else
         self.reason = nil
       end
+
+      if attributes.key?(:'optional')
+        self.optional = attributes[:'optional']
+      else
+        self.optional = nil
+      end
+
+      if attributes.key?(:'subscriptions')
+        self.subscriptions = attributes[:'subscriptions']
+      else
+        self.subscriptions = nil
+      end
     end
 
     # Show invalid properties with the reasons. Usually used together with valid?
@@ -139,6 +161,14 @@ module LicenseManager
         invalid_properties.push('invalid value for "reason", reason cannot be nil.')
       end
 
+      if @optional.nil?
+        invalid_properties.push('invalid value for "optional", optional cannot be nil.')
+      end
+
+      if @subscriptions.nil?
+        invalid_properties.push('invalid value for "subscriptions", subscriptions cannot be nil.')
+      end
+
       invalid_properties
     end
 
@@ -151,6 +181,8 @@ module LicenseManager
       access_validator = EnumAttributeValidator.new('String', ["Read", "Write", "unknown_default_open_api"])
       return false unless access_validator.valid?(@access)
       return false if @reason.nil?
+      return false if @optional.nil?
+      return false if @subscriptions.nil?
       true
     end
 
@@ -184,6 +216,26 @@ module LicenseManager
       @reason = reason
     end
 
+    # Custom attribute writer method with validation
+    # @param [Object] optional Value to be assigned
+    def optional=(optional)
+      if optional.nil?
+        fail ArgumentError, 'optional cannot be nil'
+      end
+
+      @optional = optional
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] subscriptions Value to be assigned
+    def subscriptions=(subscriptions)
+      if subscriptions.nil?
+        fail ArgumentError, 'subscriptions cannot be nil'
+      end
+
+      @subscriptions = subscriptions
+    end
+
     # Checks equality by comparing each attribute.
     # @param [Object] Object to be compared
     def ==(o)
@@ -191,7 +243,9 @@ module LicenseManager
       self.class == o.class &&
           resource == o.resource &&
           access == o.access &&
-          reason == o.reason
+          reason == o.reason &&
+          optional == o.optional &&
+          subscriptions == o.subscriptions
     end
 
     # @see the `==` method
@@ -203,7 +257,7 @@ module LicenseManager
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [resource, access, reason].hash
+      [resource, access, reason, optional, subscriptions].hash
     end
 
     # Builds the object from hash

data/lib/license_manager/models/stripe_price.rb

@@ -25,6 +25,8 @@ module LicenseManager
 
     attr_accessor :price
 
+    attr_accessor :recurring
+
     # Whether the price already creates licenses of a product.
     attr_accessor :mapped
 
@@ -36,6 +38,7 @@ module LicenseManager
         :'product_name' => :'productName',
         :'nickname' => :'nickname',
         :'price' => :'price',
+        :'recurring' => :'recurring',
         :'mapped' => :'mapped'
       }
     end
@@ -58,6 +61,7 @@ module LicenseManager
         :'product_name' => :'String',
         :'nickname' => :'String',
         :'price' => :'Price',
+        :'recurring' => :'StripePriceRecurring',
         :'mapped' => :'Boolean'
       }
     end
@@ -67,6 +71,7 @@ module LicenseManager
       Set.new([
         :'nickname',
         :'price',
+        :'recurring',
       ])
     end
 
@@ -126,6 +131,12 @@ module LicenseManager
         self.price = nil
       end
 
+      if attributes.key?(:'recurring')
+        self.recurring = attributes[:'recurring']
+      else
+        self.recurring = nil
+      end
+
       if attributes.key?(:'mapped')
         self.mapped = attributes[:'mapped']
       else
@@ -218,6 +229,7 @@ module LicenseManager
           product_name == o.product_name &&
           nickname == o.nickname &&
           price == o.price &&
+          recurring == o.recurring &&
           mapped == o.mapped
     end
 
@@ -230,7 +242,7 @@ module LicenseManager
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [id, product_id, product_name, nickname, price, mapped].hash
+      [id, product_id, product_name, nickname, price, recurring, mapped].hash
     end
 
     # Builds the object from hash

data/lib/license_manager/models/stripe_price_recurring.rb

@@ -0,0 +1,228 @@
+=begin
+#LicenseManager API
+
+#Public API. Authenticate with an organization API key, or with a token scoped to a customer, license or machine on the endpoints that accept one.  ## Conventions  - **Errors** answer `{ \"error\": { \"code\", \"message\" } }`. Branch on `code`, which is stable, not on `message`. Each response lists the codes it can return, except `404`, which answers `not_found` unless it says otherwise. Unexpected errors answer `500` with `internal_error`. - **Validation** errors answer `422`, not `400`, with the `validation_error` code and an `issues` array giving the `path` and `message` of each invalid value. - **Unknown body fields are ignored**, not rejected: sending a field an endpoint doesn't accept, like `policyId` to `updateLicense`, changes nothing and doesn't fail. - **Strings** are trimmed before they're validated and stored. Emails are stored lower cased. - **Updates** only change the fields that are sent. A field sent as `null` is cleared, when it can be. - **Dates** can be sent with any offset, and are always returned in UTC, like `2026-01-15T09:30:00.000Z`. Calendar months and days are counted in UTC. - **Ids** are 8 letters and digits, after `test_` for test products and their resources. - **Lists** are paginated with `page` and `pageSize`. Items with the same value for the `sort` field are ordered by id, so pages are stable, but items created or deleted between two requests shift the pages. Items without a value for the `sort` field come last in ascending order, and first in descending order, unless the endpoint says otherwise. - **Test products** are sandboxes of a live product. Test API keys only reach test products, live API keys only live ones: the others answer `404`, as if they didn't exist. Sessions and tokens reach both.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.26.0
+
+=end
+
+require 'date'
+require 'time'
+
+module LicenseManager
+  # Billing period of a recurring price, `null` for a one-time price.
+  class StripePriceRecurring < ApiModelBase
+    attr_accessor :interval
+
+    attr_accessor :interval_count
+
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'interval' => :'interval',
+        :'interval_count' => :'intervalCount'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'interval' => :'String',
+        :'interval_count' => :'Integer'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Returns attribute type mapping
+    def self.acceptable_openapi_types
+      openapi_types
+    end
+
+    # Returns the nullable attributes
+    def self.acceptable_openapi_nullable
+      openapi_nullable
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `LicenseManager::StripePriceRecurring` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `LicenseManager::StripePriceRecurring`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'interval')
+        self.interval = attributes[:'interval']
+      else
+        self.interval = nil
+      end
+
+      if attributes.key?(:'interval_count')
+        self.interval_count = attributes[:'interval_count']
+      else
+        self.interval_count = nil
+      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
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @interval.nil?
+        invalid_properties.push('invalid value for "interval", interval cannot be nil.')
+      end
+
+      if @interval_count.nil?
+        invalid_properties.push('invalid value for "interval_count", interval_count cannot be nil.')
+      end
+
+      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?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @interval.nil?
+      interval_validator = EnumAttributeValidator.new('String', ["day", "week", "month", "year", "unknown_default_open_api"])
+      return false unless interval_validator.valid?(@interval)
+      return false if @interval_count.nil?
+      true
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] interval Object to be assigned
+    def interval=(interval)
+      validator = EnumAttributeValidator.new('String', ["day", "week", "month", "year", "unknown_default_open_api"])
+      unless validator.valid?(interval)
+        fail ArgumentError, "invalid value for \"interval\", must be one of #{validator.allowable_values}."
+      end
+      @interval = interval
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] interval_count Value to be assigned
+    def interval_count=(interval_count)
+      if interval_count.nil?
+        fail ArgumentError, 'interval_count cannot be nil'
+      end
+
+      @interval_count = interval_count
+    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 &&
+          interval == o.interval &&
+          interval_count == o.interval_count
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [interval, interval_count].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      # include attributes inherited from allOf parents (the nearest declaration wins)
+      map = acceptable_attribute_map
+      transformed_hash = {}
+      acceptable_openapi_types.each_pair do |key, type|
+        if attributes.key?(map[key]) && attributes[map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif 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[map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      # include attributes inherited from allOf parents (the nearest declaration wins)
+      self.class.acceptable_attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.acceptable_openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end