microslop_one_drive 2.2.0 → 3.1.0

data/lib/microslop_one_drive/drive_item.rb

@@ -4,53 +4,70 @@ module MicroslopOneDrive
 
     attr_reader :id,
                 :name,
-                :created_at,
-                :updated_at,
-                :url,
+                :download_url,
+                :web_url,
                 :size,
+                :created_date_time,
+                :last_modified_date_time,
+                :e_tag,
+                :c_tag,
                 :file_or_folder,
-                :parent_id,
                 :mime_type,
-                :parent,
-                :children,
-                :path,
-                :full_path
-
-    def initialize(item_hash)
-      @item_hash = item_hash
-
-      @id = @item_hash.fetch("id", nil)
-      @name = @item_hash.fetch("name", nil)
-      @url = @item_hash.fetch("webUrl", nil)
-      @size = @item_hash.fetch("size", nil)
-
-      @created_at = Utils.safe_parse_time(@item_hash.fetch("createdDateTime", nil))
-      @updated_at = Utils.safe_parse_time(@item_hash.fetch("lastModifiedDateTime", nil))
-
-      if @item_hash.key?("file")
-        @file_or_folder = :file
-        @mime_type = @item_hash.dig("file", "mimeType")
-      elsif @item_hash.key?("folder")
-        @file_or_folder = :folder
-        @mime_type = DIRECTORY_MIME_TYPE
-      end
-
-      @parent_id = @item_hash.dig("parentReference", "id")
-
-      @deleted = @item_hash.dig("deleted", "state") == "deleted"
+                :parent_reference,
+                :is_deleted,
+                :is_shared,
+                :full_path,
+                :path
+
+    def initialize(
+      id:,
+      name:,
+      download_url:,
+      web_url:,
+      size:,
+      created_date_time:,
+      last_modified_date_time:,
+      e_tag:,
+      c_tag:,
+      file_or_folder:,
+      mime_type:,
+      parent_reference:,
+      is_deleted:,
+      is_shared:
+    )
+      @id = id
+      @name = name
+      @download_url = download_url
+      @web_url = web_url
+      @size = size
+      @created_date_time = created_date_time
+      @last_modified_date_time = last_modified_date_time
+      @e_tag = e_tag
+      @c_tag = c_tag
+      @file_or_folder = file_or_folder
+      @mime_type = mime_type
+      @parent_reference = parent_reference
+      @is_deleted = is_deleted
+      @is_shared = is_shared
+
+      @full_path = build_full_path
+      @path = build_path(@full_path)
+    end
 
-      @path = build_path
+    def created_at
+      @created_date_time
+    end
 
-      @parent = nil
-      @children = []
+    def updated_at
+      @last_modified_date_time
     end
 
     def deleted?
-      @deleted
+      @is_deleted
     end
 
     def shared?
-      @item_hash.key?("shared")
+      @is_shared
     end
 
     def file?
@@ -61,39 +78,20 @@ module MicroslopOneDrive
       @file_or_folder == :folder
     end
 
-    def set_parent(parent)
-      if @parent
-        @parent.remove_child(self)
-      end
-
-      @parent = parent
-      @parent.add_child(self)
-    end
-
-    def is_root?
-      @item_hash.key?("root")
+    def root?
+      false
     end
 
-    protected
+    def build_full_path
+      return nil if parent_reference&.path.nil? || name.nil?
 
-    def add_child(child)
-      @children << child
+      ::File.join(parent_reference.path, name)
     end
 
-    def remove_child(child)
-      @children.delete(child)
-    end
-
-    private
-
-    def build_path
-      return "root:" if is_root?
-
-      full_parent_path = @item_hash.dig("parentReference", "path")
-      return nil if full_parent_path.nil?
+    def build_path(full_path)
+      return "" if full_path.nil?
 
-      full_path_with_name = File.join(full_parent_path, @name)
-      full_path_with_name.sub(/\A.*root:\//, "root:/")
+      full_path.gsub(%r{\A/?drive/root:/?}, "").chomp("/")
     end
   end
 end

data/lib/microslop_one_drive/endpoints/all_drives.rb

@@ -0,0 +1,17 @@
+module MicroslopOneDrive
+  module Endpoints
+    module AllDrives
+      # 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 all_drives
+        response = get(path: "me/drives", query: {})
+        handle_error(response) unless response.success?
+        MicroslopOneDrive::ListResponses::DriveList.new(response.parsed_response)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/endpoints/batch.rb

@@ -0,0 +1,37 @@
+module MicroslopOneDrive
+  module Endpoints
+    module Batch
+      BATCH_REQUEST_LIMIT = 20 # This is set by Microsoft
+
+      # 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::Batch::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
+          response = post(path: "$batch", body: {requests: it}.to_json)
+          handle_error(response) unless response.success?
+          new_responses = response.parsed_response.fetch("responses", [])
+          new_responses.each do
+            batch_response.add_response(MicroslopOneDrive::Batch::Response.new(it))
+          end
+        end
+
+        batch_response
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/endpoints/batch_permissions.rb

@@ -0,0 +1,42 @@
+module MicroslopOneDrive
+  module Endpoints
+    module BatchPermissions
+      # 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 drive_id [String, nil] The ID of the Drive to get the permissions of. If not provided, the current User's
+      # default Drive will be used.
+      # @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:, drive_id: nil)
+        requests = build_batch_permissions_requests(item_ids: item_ids, drive_id: drive_id)
+        batch_response = batch(requests: requests)
+        successful_responses = batch_response.responses.select(&:success?)
+
+        permission_lists = successful_responses.map do
+          MicroslopOneDrive::ListResponses::PermissionList.new(
+            drive_item_id: it.id,
+            parsed_response: it.body
+          )
+        end
+
+        permission_lists.flat_map(&:permissions)
+      end
+
+      private
+
+      def build_batch_permissions_requests(item_ids:, drive_id: nil)
+        if drive_id.nil?
+          item_ids.map { {id: it, method: "GET", url: "/me/drive/items/#{it}/permissions"} }
+        else
+          item_ids.map { {id: it, method: "GET", url: "/me/drives/#{drive_id}/items/#{it}/permissions"} }
+        end
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/endpoints/delta.rb

@@ -0,0 +1,19 @@
+module MicroslopOneDrive
+  module Endpoints
+    module Delta
+      # Gets a delta of changes in a Drive.
+      #
+      # @param drive_id [String, nil] The ID of the Drive to get the delta of. If not provided, the current User's default
+      # Drive will be used.
+      # @param token [String, nil] The token to use for the delta. If not provided, the initial delta will be returned.
+      #
+      # @return [MicroslopOneDrive::DriveItemList]
+      def delta(drive_id: nil, token: nil)
+        url = drive_id.nil? ? "me/drive/root/delta" : "me/drives/#{drive_id}/root/delta"
+        response = get(path: url, query: {token: token})
+        handle_error(response) unless response.success?
+        MicroslopOneDrive::ListResponses::DriveItemList.new(response.parsed_response)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/endpoints/drive.rb

@@ -0,0 +1,27 @@
+module MicroslopOneDrive
+  module Endpoints
+    module Drive
+      # Gets a Drive.
+      #
+      # If no drive_id is provided, the current User's default Drive will be returned, else, the specific Drive identified
+      # by the drive_id will be returned.
+      #
+      # From the docs:
+      #
+      # > Most users will only have a single Drive resource.
+      # > Groups and Sites may have multiple Drive resources available.
+      #
+      # @param drive_id [String, nil] The ID of the Drive to get. If not provided, the current User's default Drive will
+      # be returned.
+      #
+      # @return [MicroslopOneDrive::Drive]
+      def drive(drive_id: nil)
+        url = drive_id.nil? ? "me/drive" : "me/drives/#{drive_id}"
+        response = get(path: url, query: {})
+
+        handle_error(response) unless response.success?
+        MicroslopOneDrive::Deserializers::DriveDeserializer.create_from_hash(response.parsed_response)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/endpoints/drive_exists.rb

@@ -0,0 +1,15 @@
+module MicroslopOneDrive
+  module Endpoints
+    module DriveExists
+      # 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
+    end
+  end
+end

data/lib/microslop_one_drive/endpoints/drive_item.rb

@@ -0,0 +1,20 @@
+module MicroslopOneDrive
+  module Endpoints
+    module DriveItem
+      # Gets a specific DriveItem (folder or file)
+      #
+      # @param drive_id [String, nil] The ID of the Drive to get the Drive Item from. If not provided, the current User's
+      # default Drive will be used.
+      # @param item_id [String] The ID of the Drive Item to get.
+      #
+      # @return [MicroslopOneDrive::DriveItem]
+      def drive_item(item_id:, drive_id: nil)
+        url = drive_id.nil? ? "me/drive/items/#{item_id}" : "me/drives/#{drive_id}/items/#{item_id}"
+        response = get(path: url, query: {})
+
+        handle_error(response) unless response.success?
+        MicroslopOneDrive::Deserializers::DriveItemDeserializer.create_from_hash(response.parsed_response)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/endpoints/drive_item_exists.rb

@@ -0,0 +1,22 @@
+module MicroslopOneDrive
+  module Endpoints
+    module DriveItemExists
+      # Asks if a DriveItem (folder or file) exists by its ID.
+      #
+      # @param drive_id [String, nil] The ID of the Drive to check the Drive Item in. If not provided, the current User's
+      # default Drive will be used.
+      # @param item_id [String] The ID of the Drive Item to check.
+      #
+      # @return [Boolean]
+      def drive_item_exists?(item_id:, drive_id: nil)
+        url = drive_id.nil? ? "me/drive/items/#{item_id}" : "me/drives/#{drive_id}/items/#{item_id}"
+        response = get(path: url, query: {})
+
+        return false if response.code == 404
+        return true if response.success?
+
+        handle_error(response)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/endpoints/me.rb

@@ -0,0 +1,14 @@
+module MicroslopOneDrive
+  module Endpoints
+    module Me
+      # Gets the current user
+      #
+      # @return [MicroslopOneDrive::User]
+      def me
+        response = get(path: "me", query: {})
+        handle_error(response) unless response.success?
+        MicroslopOneDrive::Deserializers::UserDeserializer.create_from_hash(response.parsed_response)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/endpoints/permissions.rb

@@ -0,0 +1,36 @@
+module MicroslopOneDrive
+  module Endpoints
+    module Permissions
+      # Gets the permissions for a DriveItem (folder or file) in a Drive.
+      #
+      # @param drive_id [String, nil] The ID of the Drive to get the permissions of. If not provided, the current User's
+      # default Drive will be used.
+      # @param item_id [String] The ID of the Drive Item to get the permissions of.
+      #
+      # @return [MicroslopOneDrive::PermissionList]
+      def permissions(item_id:, drive_id: nil)
+        url = if drive_id.nil?
+                "me/drive/items/#{item_id}/permissions"
+              else
+                "me/drives/#{drive_id}/items/#{item_id}/permissions"
+              end
+
+        response = get(path: url, query: {})
+
+        if response.code == 404
+          return MicroslopOneDrive::ListResponses::PermissionList.new(
+            drive_item_id: item_id,
+            parsed_response: {"value" => []}
+          )
+        end
+
+        handle_error(response) unless response.success?
+
+        MicroslopOneDrive::ListResponses::PermissionList.new(
+          drive_item_id: item_id,
+          parsed_response: response.parsed_response
+        )
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/endpoints/shared_with_me.rb

@@ -0,0 +1,14 @@
+module MicroslopOneDrive
+  module Endpoints
+    module SharedWithMe
+      # Gets the Drive Items shared with the current user.
+      #
+      # @return [MicroslopOneDrive::SharedWithMeList]
+      def shared_with_me
+        response = get(path: "me/drive/sharedWithMe")
+        handle_error(response) unless response.success?
+        MicroslopOneDrive::ListResponses::SharedWithMeList.new(response.parsed_response)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/endpoints/supports_sites.rb

@@ -0,0 +1,27 @@
+module MicroslopOneDrive
+  module Endpoints
+    module SupportsSites
+      # Asks if the user's account supports SharePoint.
+      #
+      # Does this by checking if the user's account has a root SharePoint Site.
+      #
+      # @return [Boolean]
+      def supports_sites?
+        response = get(path: "me/sites/root", query: {})
+
+        return true if response.success?
+        return false if response_indicates_no_sites?(response)
+
+        handle_error(response)
+      end
+
+      private
+
+      def response_indicates_no_sites?(response)
+        response.bad_request? &&
+        response.parsed_response.dig("error", "code") == "BadRequest" &&
+        response.parsed_response.dig("error", "message").match?(/This API is not supported for MSA accounts/i)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/file.rb

@@ -0,0 +1,13 @@
+require "microslop_one_drive/drive_item"
+
+module MicroslopOneDrive
+  class File < DriveItem
+    def folder?
+      false
+    end
+
+    def file?
+      true
+    end
+  end
+end

data/lib/microslop_one_drive/folder.rb

@@ -0,0 +1,13 @@
+require "microslop_one_drive/drive_item"
+
+module MicroslopOneDrive
+  class Folder < DriveItem
+    def folder?
+      true
+    end
+
+    def file?
+      false
+    end
+  end
+end

data/lib/microslop_one_drive/list_responses/drive_item_list.rb

@@ -0,0 +1,21 @@
+module MicroslopOneDrive
+  module ListResponses
+    class DriveItemList < ListResponse
+      attr_reader :items
+
+      def initialize(parsed_response)
+        super
+
+        @items = build_items(parsed_response)
+      end
+
+      private
+
+      def build_items(parsed_response)
+        parsed_response.fetch("value", []).map do
+          MicroslopOneDrive::Deserializers::DriveItemDeserializer.create_from_hash(it)
+        end
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/list_responses/drive_list.rb

@@ -0,0 +1,15 @@
+module MicroslopOneDrive
+  module ListResponses
+    class DriveList < ListResponse
+      attr_reader :drives
+
+      def initialize(response_hash)
+        super
+
+        @drives = response_hash.fetch("value", []).map do
+          MicroslopOneDrive::Deserializers::DriveDeserializer.create_from_hash(it)
+        end
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/list_responses/list_response.rb

@@ -0,0 +1,21 @@
+module MicroslopOneDrive
+  module ListResponses
+    class ListResponse
+      attr_reader :next_link, :next_token, :delta_link, :delta_token, :context
+
+      def initialize(response_hash)
+        @context = response_hash.fetch("@odata.context", nil)
+
+        @next_link = response_hash.fetch("@odata.nextLink", nil)
+        @next_token = @next_link.split("?token=").last if @next_link && !@next_link.empty?
+
+        @delta_link = response_hash.fetch("@odata.deltaLink", nil)
+        @delta_token = @delta_link.split("?token=").last if @delta_link && !@delta_link.empty?
+      end
+
+      def next_page?
+        !next_link.nil?
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/list_responses/permission_list.rb

@@ -0,0 +1,27 @@
+module MicroslopOneDrive
+  module ListResponses
+    class PermissionList < ListResponse
+      attr_reader :permissions
+
+      def initialize(drive_item_id:, parsed_response:)
+        super(parsed_response)
+
+        @permissions = build_permissions(drive_item_id, parsed_response)
+      end
+
+      private
+
+      def build_permissions(drive_item_id, parsed_response)
+        permission_sets = parsed_response.fetch("value", []).map do
+          MicroslopOneDrive::PermissionSet.new(drive_item_id: drive_item_id, parsed_response: it)
+        end
+
+        # At this stage, the permissions could contain multiple Audiences for the same Permission.
+        # This is because OneDrive can return multiple permissions for the same thing.
+        # For example, a file shared with one person and a public link will return in a single permission object.
+        # We therefore need to "explode" the permission sets into multiple permissions, one for each Audience.
+        permission_sets.flat_map(&:to_permissions)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/list_responses/shared_with_me_list.rb

@@ -0,0 +1,15 @@
+module MicroslopOneDrive
+  module ListResponses
+    class SharedWithMeList < ListResponse
+      attr_reader :shared_with_me_items
+
+      def initialize(response_hash)
+        super
+
+        @shared_with_me_items = response_hash.fetch("value", []).map do
+          MicroslopOneDrive::Deserializers::SharedWithMeItemDeserializer.create_from_hash(it)
+        end
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/parent_reference.rb

@@ -0,0 +1,14 @@
+module MicroslopOneDrive
+  class ParentReference
+    attr_reader :drive_type, :drive_id, :id, :name, :path, :site_id
+
+    def initialize(drive_type:, drive_id:, id:, name:, path:, site_id:)
+      @drive_type = drive_type
+      @drive_id = drive_id
+      @id = id
+      @name = name
+      @path = path
+      @site_id = site_id
+    end
+  end
+end

data/lib/microslop_one_drive/permission_set.rb

@@ -3,12 +3,10 @@ module MicroslopOneDrive
     attr_reader :id, :role, :audiences
 
     def initialize(drive_item_id:, parsed_response:)
-      @parsed_response = parsed_response
-
       @drive_item_id = drive_item_id
-      @id = @parsed_response.fetch("id", nil)
-      @role = build_role
-      @audiences = build_audiences
+      @id = parsed_response.fetch("id", nil)
+      @role = build_role(parsed_response)
+      @audiences = build_audiences(parsed_response)
     end
 
     def to_permissions
@@ -17,31 +15,31 @@ module MicroslopOneDrive
 
     private
 
-    def build_role
-      roles = @parsed_response.fetch("roles", [])
+    def build_role(parsed_response)
+      roles = parsed_response.fetch("roles", [])
       roles.is_a?(Array) ? roles.first : roles
     end
 
-    def build_audiences
+    def build_audiences(parsed_response)
       audiences = []
 
-      audiences += audiences_from_site_users
-      audiences += audiences_from_anonymous_links
+      audiences += audiences_from_site_users(parsed_response)
+      audiences += audiences_from_anonymous_links(parsed_response)
 
       audiences.compact
     end
 
-    def audiences_from_site_users
+    def audiences_from_site_users(parsed_response)
       site_users = []
-      site_users += @parsed_response.fetch("grantedToIdentitiesV2", []).flat_map { it.fetch("siteUser", nil) }
-      site_users << @parsed_response.dig("grantedToV2", "siteUser")
+      site_users += parsed_response.fetch("grantedToIdentitiesV2", []).flat_map { it.fetch("siteUser", nil) }
+      site_users << parsed_response.dig("grantedToV2", "siteUser")
       site_users.compact!
 
       site_users.map { Audience.from_site_user(it) }
     end
 
-    def audiences_from_anonymous_links
-      link = @parsed_response.fetch("link", nil)
+    def audiences_from_anonymous_links(parsed_response)
+      link = parsed_response.fetch("link", nil)
       return [] if link.nil? || (link.respond_to?(:empty?) && link.empty?)
 
       link_scope = link.fetch("scope", nil)