microslop_one_drive 2.2.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ecb37d7c06f4bdccc20efb969d008a164b04e1b9af749a548b7619533d1ecf0
-  data.tar.gz: '058058b75f1631a1d6c1ea16437564cff90629794713adb1125f67cb9a1aa405'
+  metadata.gz: 9db184b4df0a4b6a58972d944c9c9abea1e898d81be33f180fc041fbd79c2a99
+  data.tar.gz: 21d761f38fb51a2985f49e082dd592f1f3e9361d39a38749ba44715360d9899d
 SHA512:
-  metadata.gz: 52c178fb870ddda9248b1cf7d1efd453d075e3ceafbaece55b3011cc9403fe860fd57a7b971342293e9cbe13dd79677ea93d2ffb67060acaf182b6df087de6b0
-  data.tar.gz: aa23a4524e2ffa81fb1e7b14f8cf6fb79ffcdbd37f1867e0fe1f4a5106469edfc5964d68131a8b035ff7d75ddaaf19e09c0c37cfb8322799340ee6b86270f1e4
+  metadata.gz: fa9435c4a163c94012c88461c9330048ae08870a4cdf9fc0d4f8a31895aeac85ae3948fa5b420e4ec06bd00f2b202bdac25c968ad58dc36a1d905b0aff60ac55
+  data.tar.gz: ebd2a33ffbf3880edc209a176371c15963df82642f6ed69167b32cf0867eadf5fddf2b06cab59b936c509a1df82cded8b2a6728b4e10513d7680f1835601c17b

data/README.md

@@ -16,8 +16,7 @@ gem "microslop_one_drive"
 
 ## Usage
 
-Here's a quickstart showing listing drives, getting some files in a drive, and getting permissions for some files in
-a batched manner:
+Quickstart: current user, drives, drive items, shared-with-me, delta (changes), and permissions (single or batched).
 
 ### Creating a client
 
@@ -25,6 +24,17 @@ a batched manner:
 access_token = "..." # Get an access token via OAuth 2.0
 
 client = MicroslopOneDrive::Client.new(access_token)
+
+# Optional: pass a logger to log all API requests and responses (e.g. Rails.logger)
+client = MicroslopOneDrive::Client.new(access_token, logger: Rails.logger)
+```
+
+### Get current user
+
+```rb
+user = client.me
+user.display_name # => "Jane Doe"
+user.email_address # => "jane@example.com"
 ```
 
 ### Listing Drives
@@ -34,7 +44,7 @@ Note: Microsoft will return all Drives a user has access to. Some of these seem
 `drive_exists?()` method to check if it's a real drive you can interact with.
 
 ```rb
-drive_list = client.drives
+drive_list = client.all_drives
 drive_list.drives.size # => 2
 
 drive = drive_list.drives[1]
@@ -44,6 +54,29 @@ drive.id # => "0f0**********42"
 client.drive_exists?(drive.id) # => true (it's a real Drive)
 ```
 
+### Get a single drive
+
+```rb
+# Default (current user's) drive
+drive = client.drive
+
+# Or a specific drive by ID
+drive = client.drive(drive_id: "0f0**********42")
+drive.name # => "OneDrive"
+```
+
+### Get a single drive item
+
+```rb
+item = client.drive_item(item_id: "01ABC123...", drive_id: drive.id)
+item.name # => "My Document.docx"
+item.file? # => true
+item.folder? # => false
+
+# Check if an item exists without raising
+client.drive_item_exists?(item_id: "01ABC123...", drive_id: drive.id) # => true
+```
+
 ### Listing Drive Items (Folders and Files)
 
 ```rb
@@ -59,6 +92,34 @@ delta_token = page2.delta_token # Save this somewhere and use as "token" in the
 # only get new changes, and don't list the whole drive from the beginning again.
 ```
 
+### Shared with me
+
+Get drive items (files and folders) that others have shared with the current user.
+
+```rb
+shared_list = client.shared_with_me
+shared_list.shared_with_me_items.size # => 5
+
+item = shared_list.shared_with_me_items.first
+item.name # => "Spreadsheet One.xlsx"
+item.id # => "64E5DD3210FD6004!s1d8ad87a1d6e4d4e..."
+item.web_url # => "https://onedrive.live.com?cid=..."
+item.size # => 6183
+item.created_at # => 2026-02-17 14:27:26 UTC
+item.updated_at # => 2026-02-17 14:27:27 UTC
+
+# Who shared it
+item.created_by.display_name # => "Someone Else"
+item.created_by.email_address # => "outlook_64E5DD3210FD6004@outlook.com"
+item.last_modified_by.display_name # => "Someone Else"
+
+# The underlying drive item (with file?, folder?, mime_type, shared?, etc.)
+item.remote_item.file? # => true
+item.remote_item.shared? # => true
+```
+
+Use `shared_list.next_page?` and `shared_list.next_token` to paginate when there are many items.
+
 ### Get Permissions for a single Drive Item
 
 ```rb
@@ -86,10 +147,15 @@ Microsoft Graph API [batch](https://learn.microsoft.com/en-us/graph/json-batchin
 drive_item_list = client.delta(drive_id: drive.id)
 shared_items = drive_item_list.items.select(&:shared?)
 
-permission_batch = client.batch_permissions(item_ids: shared_items.map(&:id))
+permissions = client.batch_permissions(item_ids: shared_items.map(&:id))
+# Returns a flat array of MicroslopOneDrive::Permission (batches of 20 are made under the hood).
+permissions.each { |p| puts "#{p.audience.display_name}: #{p.role}" }
+```
+
+### Checking if the user's accounts supports SharePoint Sites
 
-# Under the hood, this will batch the shared_items into batches of 20 (the max Microsoft allows on their batch endpoint)
-# and returns an aggregated result.
+```rb
+client.supports_sites? # => true or false
 ```
 
 ## Contributing

data/lib/microslop_one_drive/batch/batch_response.rb

@@ -0,0 +1,15 @@
+module MicroslopOneDrive
+  module Batch
+    class BatchResponse
+      attr_reader :responses
+
+      def initialize
+        @responses = []
+      end
+
+      def add_response(response)
+        @responses << response
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/batch/response.rb

@@ -0,0 +1,18 @@
+module MicroslopOneDrive
+  module Batch
+    class Response
+      attr_reader :id, :status, :headers, :body
+
+      def initialize(response_hash)
+        @id = response_hash.fetch("id")
+        @status = response_hash.fetch("status")
+        @headers = response_hash.fetch("headers")
+        @body = response_hash.fetch("body")
+      end
+
+      def success?
+        @status.between?(200, 299)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/client.rb

@@ -3,7 +3,19 @@ require "json"
 module MicroslopOneDrive
   class Client
     BASE_URL = "https://graph.microsoft.com/v1.0".freeze
-    BATCH_REQUEST_LIMIT = 20.freeze
+
+    include Endpoints::Me
+    include Endpoints::Drive
+    include Endpoints::AllDrives
+    include Endpoints::DriveExists
+    include Endpoints::DriveItem
+    include Endpoints::DriveItemExists
+    include Endpoints::Delta
+    include Endpoints::SharedWithMe
+    include Endpoints::Permissions
+    include Endpoints::Batch
+    include Endpoints::BatchPermissions
+    include Endpoints::SupportsSites
 
     # @param access_token [String] OAuth access token for Microsoft Graph.
     # @param logger [Object, nil] Optional logger (e.g. Rails.logger) that responds to +#info+, +#debug+, +#warn+, +#error+.
@@ -19,163 +31,13 @@ module MicroslopOneDrive
       }
     end
 
-    # Gets the current user
-    #
-    # @return [MicroslopOneDrive::User]
-    def me
-      response = get(path: "me", query: {})
-      handle_error(response) unless response.success?
-      MicroslopOneDrive::User.new(response.parsed_response)
-    end
-
-    # Gets all Drives the current user has access to.
-    #
-    # NOTE: This will include some internal Microsoft drives that aren't real drives, such as AI, Face scans, and other
-    # shitty things.
-    #
-    # @return [MicroslopOneDrive::DriveList]
-    def drives
-      response = get(path: "me/drives", query: {})
-      handle_error(response) unless response.success?
-      MicroslopOneDrive::DriveList.new(response.parsed_response)
-    end
-
-    # Gets a specific Drive by its ID.
-    #
-    # @param drive_id [String] The ID of the Drive to get.
-    #
-    # @return [MicroslopOneDrive::Drive]
-    def drive(drive_id:)
-      response = get(path: "me/drives/#{drive_id}", query: {})
-      handle_error(response) unless response.success?
-      MicroslopOneDrive::Drive.new(response.parsed_response)
-    end
-
-    # Asks if a Drive exists by its ID.
-    #
-    # @param drive_id [String] The ID of the Drive to check.
-    #
-    # @return [Boolean]
-    def drive_exists?(drive_id:)
-      response = get(path: "me/drives/#{drive_id}", query: {})
-      response.success?
-    end
-
-    # Gets a specific DriveItem (folder or file) by its ID.
-    #
-    # @param item_id [String] The ID of the Drive Item to get.
-    #
-    # @return [MicroslopOneDrive::DriveItem]
-    def drive_item(item_id:)
-      response = get(path: "me/drive/items/#{item_id}", query: {})
-      handle_error(response) unless response.success?
-      MicroslopOneDrive::DriveItem.new(response.parsed_response)
-    end
-
-    # Asks if a DriveItem (folder or file) exists by its ID.
-    #
-    # @param item_id [String] The ID of the Drive Item to check.
-    #
-    # @return [Boolean]
-    def item_exists?(item_id:)
-      response = get(path: "me/drive/items/#{item_id}", query: {})
-
-      return false if response.code == 404
-      return true if response.success?
-
-      handle_error(response)
-    end
-
-    # Gets a delta of changes to a Drive.
-    #
-    # @param drive_id [String] The ID of the Drive to get the delta of.
-    # @param token [String] The token to use for the delta. If not provided, the initial delta will be returned.
-    #
-    # @return [MicroslopOneDrive::DriveItemList]
-    def delta(drive_id:, token: nil)
-      response = get(path: "me/drives/#{drive_id}/root/delta", query: {token: token})
-      handle_error(response) unless response.success?
-      MicroslopOneDrive::DriveItemList.new(response.parsed_response)
-    end
-
-    # Gets the permissions for a DriveItem (folder or file).
-    #
-    # @param item_id [String] The ID of the Drive Item to get the permissions of.
-    #
-    # @return [MicroslopOneDrive::PermissionList]
-    def permissions(item_id:)
-      response = get(path: "me/drive/items/#{item_id}/permissions", query: {})
-
-      if response.code == 404
-        return MicroslopOneDrive::PermissionList.new(drive_item_id: item_id, parsed_response: { "value" => [] })
-      end
-
-      handle_error(response) unless response.success?
-
-      MicroslopOneDrive::PermissionList.new(drive_item_id: item_id, parsed_response: response.parsed_response)
-    end
-
-    # Gets the permissions for multiple Drive Items.
-    #
-    # Uses the batch Microsoft Graph API to make multiple API calls in batches of 20 (the max Microsoft allows on their
-    # batch endpoint).
-    #
-    # See: https://learn.microsoft.com/en-us/graph/json-batching
-    #
-    # @param item_ids [Array<String>] The IDs of the Drive Items to get the permissions of.
-    #
-    # @return [Array<MicroslopOneDrive::Permission>]
-    def batch_permissions(item_ids:)
-      requests = item_ids.map { |item_id| { id: item_id, method: "GET", url: "/me/drive/items/#{item_id}/permissions" } }
-      batch_response = batch(requests: requests)
-      successful_responses = batch_response.responses.select(&:success?)
-
-      permission_lists = successful_responses.map do |response|
-        MicroslopOneDrive::PermissionList.new(drive_item_id: response.id, parsed_response: response.body)
-      end
-
-      permission_lists.flat_map(&:permissions)
-    end
-
-    # Makes a batch request to the Microsoft Graph API.
-    #
-    # @param requests [Array<Hash>] The requests to make. Each request should be a hash with the following keys:
-    #   - id: The ID of the request.
-    #   - method: The HTTP method to use for the request.
-    #   - url: The URL to make the request to.
-    #
-    # Note: Microsoft allows a maximum of 20 requests per batch. If you pass more than 20 requests, the client will
-    # make multiple batch requests to Microsoft. This might make this a slow method.
-    #
-    # @return [MicroslopOneDrive::BatchResponse]
-    def batch(requests:)
-      batch_response = MicroslopOneDrive::BatchResponse.new
-
-      # No requests, so simply return an empty batch response:
-      return batch_response if requests.empty?
-
-      batches = requests.each_slice(BATCH_REQUEST_LIMIT).to_a
-      batches.each do |batch|
-        response = post(path: "$batch", body: { requests: batch }.to_json)
-        handle_error(response) unless response.success?
-        new_responses = response.parsed_response.fetch("responses", [])
-        new_responses.each do |new_response_hash|
-          batch_response.add_response(MicroslopOneDrive::Response.new(new_response_hash))
-        end
-      end
-
-      batch_response
-    end
-
     private
 
     def get(path:, query: {})
       url = "#{BASE_URL}/#{path}"
-
       log_request("GET", url, query: query)
 
       response = HTTParty.get(url, headers: @headers, query: query)
-
       log_response(response, "GET", url)
 
       response
@@ -183,11 +45,9 @@ module MicroslopOneDrive
 
     def post(path:, body:)
       url = "#{BASE_URL}/#{path}"
-
       log_request("POST", url, body: body)
 
       response = HTTParty.post(url, headers: @headers, body: body)
-
       log_response(response, "POST", url)
 
       response
@@ -200,7 +60,7 @@ module MicroslopOneDrive
       @logger.info "==================== START MicroslopOneDrive #{method} #{url} ===================="
       @logger.info "Request method: #{method}"
       @logger.info "Request url: #{url}"
-      @logger.info "Request query: #{query.inspect}" if query && query.any?
+      @logger.info "Request query: #{query.inspect}" if query&.any?
       @logger.info "Request body: #{body.inspect}" if body
     end
 

data/lib/microslop_one_drive/deserializers/drive_deserializer.rb

@@ -0,0 +1,57 @@
+require "microslop_one_drive/utils"
+
+module MicroslopOneDrive
+  module Deserializers
+    class DriveDeserializer
+      # Creates a new Drive object from a hash.
+      #
+      # @param drive_hash [Hash] The hash to create the Drive object from.
+      # @return [MicroslopOneDrive::Drive] The created Drive object.
+      def self.create_from_hash(drive_hash)
+        drive_hash = Utils.deep_symbolize_keys(drive_hash)
+
+        created_by = build_created_by(drive_hash)
+        last_modified_by = build_last_modified_by(drive_hash)
+        owner = build_owner(drive_hash)
+
+        Drive.new(
+          id: drive_hash.fetch(:id, nil),
+          name: drive_hash.fetch(:name, nil),
+          description: drive_hash.fetch(:description, nil),
+          web_url: drive_hash.fetch(:webUrl, nil),
+          drive_type: drive_hash.fetch(:driveType, nil),
+          created_date_time: Utils.safe_parse_time(drive_hash.fetch(:createdDateTime, nil)),
+          last_modified_date_time: Utils.safe_parse_time(drive_hash.fetch(:lastModifiedDateTime, nil)),
+          created_by: created_by,
+          last_modified_by: last_modified_by,
+          owner: owner,
+          quota: QuotaDeserializer.create_from_hash(drive_hash.fetch(:quota, {}))
+        )
+      end
+
+      def self.build_created_by(drive_hash)
+        created_by_hash = drive_hash.dig(:createdBy, :user)
+
+        return unless created_by_hash
+
+        UserDeserializer.create_from_hash(created_by_hash)
+      end
+
+      def self.build_last_modified_by(drive_hash)
+        last_modified_by_hash = drive_hash.dig(:lastModifiedBy, :user)
+
+        return unless last_modified_by_hash
+
+        UserDeserializer.create_from_hash(last_modified_by_hash)
+      end
+
+      def self.build_owner(drive_hash)
+        owner_hash = drive_hash.dig(:owner, :user)
+
+        return unless owner_hash
+
+        UserDeserializer.create_from_hash(owner_hash)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/deserializers/drive_item_deserializer.rb

@@ -0,0 +1,67 @@
+require "microslop_one_drive/utils"
+
+module MicroslopOneDrive
+  module Deserializers
+    class DriveItemDeserializer
+      # Creates a new DriveItem object from a hash.
+      #
+      # @param drive_item_hash [Hash] The hash to create the DriveItem object from.
+      # @return [MicroslopOneDrive::DriveItem] The created DriveItem object.
+      def self.create_from_hash(drive_item_hash)
+        drive_item_hash = Utils.deep_symbolize_keys(drive_item_hash)
+
+        parameters = build_parameters(drive_item_hash)
+
+        root = drive_item_hash.key?(:root) && parameters[:file_or_folder] == :folder
+
+        if root
+          RootFolder.new(**parameters)
+        elsif parameters[:file_or_folder] == :file
+          File.new(**parameters)
+        elsif parameters[:file_or_folder] == :folder
+          Folder.new(**parameters)
+        else
+          DriveItem.new(**parameters)
+        end
+      end
+
+      def self.build_parameters(drive_item_hash)
+        file_or_folder = drive_item_hash.key?(:file) ? :file : :folder
+        mime_type = build_mime_type(file_or_folder, drive_item_hash)
+        parent_reference = build_parent_reference(drive_item_hash)
+
+        {
+          id: drive_item_hash.fetch(:id, nil),
+          name: drive_item_hash.fetch(:name, nil),
+          download_url: drive_item_hash.fetch(:"@microsoft.graph.downloadUrl", nil),
+          web_url: drive_item_hash.fetch(:webUrl, nil),
+          size: drive_item_hash.fetch(:size, nil),
+          created_date_time: Utils.safe_parse_time(drive_item_hash.fetch(:createdDateTime, nil)),
+          last_modified_date_time: Utils.safe_parse_time(drive_item_hash.fetch(:lastModifiedDateTime, nil)),
+          e_tag: drive_item_hash.fetch(:eTag, nil),
+          c_tag: drive_item_hash.fetch(:cTag, nil),
+          file_or_folder: file_or_folder,
+          mime_type: mime_type,
+          is_deleted: drive_item_hash.dig(:deleted, :state) == "deleted",
+          is_shared: drive_item_hash.key?(:shared),
+          parent_reference: parent_reference
+        }
+      end
+
+      def self.build_mime_type(file_or_folder, drive_item_hash)
+        if file_or_folder == :file
+          drive_item_hash.dig(:file, :mimeType)
+        else
+          MicroslopOneDrive::DriveItem::DIRECTORY_MIME_TYPE
+        end
+      end
+
+      def self.build_parent_reference(drive_item_hash)
+        parent_reference_hash = drive_item_hash.fetch(:parentReference, nil)
+        return unless parent_reference_hash
+
+        ParentReferenceDeserializer.create_from_hash(parent_reference_hash)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/deserializers/parent_reference_deserializer.rb

@@ -0,0 +1,20 @@
+require "microslop_one_drive/utils"
+
+module MicroslopOneDrive
+  module Deserializers
+    class ParentReferenceDeserializer
+      def self.create_from_hash(parent_reference_hash)
+        parent_reference_hash = Utils.deep_symbolize_keys(parent_reference_hash)
+
+        ParentReference.new(
+          drive_type: parent_reference_hash.fetch(:driveType, nil),
+          drive_id: parent_reference_hash.fetch(:driveId, nil),
+          id: parent_reference_hash.fetch(:id, nil),
+          name: parent_reference_hash.fetch(:name, nil),
+          path: parent_reference_hash.fetch(:path, nil),
+          site_id: parent_reference_hash.fetch(:siteId, nil)
+        )
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/deserializers/quota_deserializer.rb

@@ -0,0 +1,24 @@
+require "microslop_one_drive/utils"
+
+module MicroslopOneDrive
+  module Deserializers
+    class QuotaDeserializer
+      # Creates a new Quota object from a hash.
+      #
+      # @param quota_hash [Hash] The hash to create the Quota object from.
+      # @return [MicroslopOneDrive::Quota] The created Quota object.
+      def self.create_from_hash(quota_hash)
+        quota_hash = Utils.deep_symbolize_keys(quota_hash)
+
+        Quota.new(
+          deleted: quota_hash.fetch(:deleted, nil),
+          remaining: quota_hash.fetch(:remaining, nil),
+          state: quota_hash.fetch(:state, nil),
+          total: quota_hash.fetch(:total, nil),
+          used: quota_hash.fetch(:used, nil),
+          upgrade_available: quota_hash.dig(:storagePlanInformation, :upgradeAvailable)
+        )
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/deserializers/shared_with_me_item_deserializer.rb

@@ -0,0 +1,48 @@
+require "microslop_one_drive/utils"
+
+module MicroslopOneDrive
+  module Deserializers
+    class SharedWithMeItemDeserializer
+      def self.create_from_hash(shared_with_me_item_hash)
+        shared_with_me_item_hash = Utils.deep_symbolize_keys(shared_with_me_item_hash)
+
+        created_by = build_created_by(shared_with_me_item_hash)
+        last_modified_by = build_last_modified_by(shared_with_me_item_hash)
+        remote_item = build_remote_item(shared_with_me_item_hash)
+
+        SharedWithMeItem.new(
+          id: shared_with_me_item_hash.fetch(:id, nil),
+          name: shared_with_me_item_hash.fetch(:name, nil),
+          web_url: shared_with_me_item_hash.fetch(:webUrl, nil),
+          size: shared_with_me_item_hash.fetch(:size, nil),
+          last_modified_date_time: Utils.safe_parse_time(shared_with_me_item_hash.fetch(:lastModifiedDateTime, nil)),
+          created_date_time: Utils.safe_parse_time(shared_with_me_item_hash.fetch(:createdDateTime, nil)),
+          created_by: created_by,
+          last_modified_by: last_modified_by,
+          remote_item: remote_item
+        )
+      end
+
+      def self.build_created_by(shared_with_me_item_hash)
+        created_by_hash = shared_with_me_item_hash.dig(:createdBy, :user)
+        return unless created_by_hash
+
+        UserDeserializer.create_from_hash(created_by_hash)
+      end
+
+      def self.build_last_modified_by(shared_with_me_item_hash)
+        last_modified_by_hash = shared_with_me_item_hash.dig(:lastModifiedBy, :user)
+        return unless last_modified_by_hash
+
+        UserDeserializer.create_from_hash(last_modified_by_hash)
+      end
+
+      def self.build_remote_item(shared_with_me_item_hash)
+        remote_item_hash = shared_with_me_item_hash.fetch(:remoteItem, {})
+        return unless remote_item_hash
+
+        DriveItemDeserializer.create_from_hash(remote_item_hash)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/deserializers/user_deserializer.rb

@@ -0,0 +1,29 @@
+require "microslop_one_drive/utils"
+
+module MicroslopOneDrive
+  module Deserializers
+    class UserDeserializer
+      # Creates a new User object from a hash.
+      #
+      # @param user_hash [Hash] The hash to create the User object from.
+      # @return [MicroslopOneDrive::User] The created User object.
+      def self.create_from_hash(user_hash)
+        user_hash = Utils.deep_symbolize_keys(user_hash)
+
+        User.new(
+          id: user_hash.fetch(:id, nil),
+          principal_name: user_hash.fetch(:userPrincipalName, nil),
+          display_name: user_hash.fetch(:displayName, nil),
+          surname: user_hash.fetch(:surname, nil),
+          given_name: user_hash.fetch(:givenName, nil),
+          preferred_language: user_hash.fetch(:preferredLanguage, nil),
+          mail: user_hash.fetch(:mail, nil) || user_hash.fetch(:email, nil),
+          mobile_phone: user_hash.fetch(:mobilePhone, nil),
+          job_title: user_hash.fetch(:jobTitle, nil),
+          office_location: user_hash.fetch(:officeLocation, nil),
+          business_phones: user_hash.fetch(:businessPhones, [])
+        )
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/drive.rb

@@ -1,18 +1,48 @@
 module MicroslopOneDrive
   class Drive
-    attr_reader :id, :name, :description, :url, :drive_type, :created_at, :updated_at
+    attr_reader :id, :name, :description, :web_url, :drive_type, :created_date_time, :last_modified_date_time,
+                :created_by, :last_modified_by, :owner, :quota
 
-    def initialize(drive_hash)
-      @drive_hash = drive_hash
+    def initialize(
+      id:,
+      name:,
+      description:,
+      web_url:,
+      drive_type:,
+      created_date_time:,
+      last_modified_date_time:,
+      created_by:,
+      last_modified_by:,
+      owner:,
+      quota:
+    )
+      @id = id
+      @name = name
+      @description = description
+      @web_url = web_url
+      @drive_type = drive_type
+      @created_date_time = created_date_time
+      @last_modified_date_time = last_modified_date_time
+      @created_by = created_by
+      @last_modified_by = last_modified_by
+      @owner = owner
+      @quota = quota
+    end
+
+    def created_at
+      @created_date_time
+    end
 
-      @id = drive_hash.fetch("id", nil)
-      @name = drive_hash.fetch("name", nil)
-      @description = drive_hash.fetch("description", nil)
-      @url = drive_hash.fetch("webUrl", nil)
-      @drive_type = drive_hash.fetch("driveType", nil)
+    def updated_at
+      @last_modified_date_time
+    end
+
+    def url
+      @web_url
+    end
 
-      @created_at = Utils.safe_parse_time(drive_hash.fetch("createdDateTime", nil))
-      @updated_at = Utils.safe_parse_time(drive_hash.fetch("lastModifiedDateTime", nil))
+    def updated_by
+      @last_modified_by
     end
   end
 end