notion 1.0.1 → 1.0.6

data/lib/notion_api/core.rb

@@ -42,13 +42,27 @@ module NotionAPI
       end
 
       block_id = clean_id
-      block_title = extract_title(clean_id, jsonified_record_response)
       block_type = extract_type(clean_id, jsonified_record_response)
       block_parent_id = extract_parent_id(clean_id, jsonified_record_response)
 
-      raise 'the URL or ID passed to the get_page method must be that of a Page Block.' if block_type != 'page'
-
-      PageBlock.new(block_id, block_title, block_parent_id)
+      raise 'the URL or ID passed to the get_page method must be that of a Page Block.' if !['collection_view_page', 'page'].include?(block_type)
+
+      if block_type == "page"
+        block_title = extract_title(clean_id, jsonified_record_response)
+        PageBlock.new(block_id, block_title, block_parent_id)
+      elsif block_type == "collection_view_page"
+        collection_id = extract_collection_id(block_id, jsonified_record_response)
+        block_title = extract_collection_title(clean_id, collection_id, jsonified_record_response)
+        view_id = extract_view_ids(block_id, jsonified_record_response)[0]
+        schema = extract_collection_schema(collection_id, view_id, jsonified_record_response)
+        column_mappings = schema.keys
+        column_names = column_mappings.map { |mapping| schema[mapping]['name']}
+
+        collection_view_page = CollectionViewPage.new(block_id, block_title, block_parent_id, collection_id, view_id)
+        collection_view_page.instance_variable_set(:@column_names, column_names)
+        CollectionView.class_eval{attr_reader :column_names}
+        collection_view_page
+      end
     end
 
     def children(url_or_id = @id)
@@ -113,11 +127,34 @@ module NotionAPI
       children_ids(url_or_id).empty? ? [] : children_ids(url_or_id)[-1]
     end
 
+    def get_block_props_and_format(clean_id, block_title)
+      request_body = {
+        pageId: clean_id,
+        chunkNumber: 0,
+        limit: 100,
+        verticalColumns: false
+      }
+      jsonified_record_response = get_all_block_info(clean_id, request_body)
+      i = 0
+      while jsonified_record_response.empty?
+        return {:properties => {title: [[block_title]]}, :format => {}} if i >= 10
+
+        jsonified_record_response = get_all_block_info(clean_id, request_body)
+        i += 1
+      end
+      properties = jsonified_record_response['block'][clean_id]['value']['properties']
+      formats = jsonified_record_response['block'][clean_id]['value']['format']
+      return {
+        :properties => properties,
+        :format => formats
+      }
+    end
+
     def get_all_block_info(_clean_id, body)
       # ! retrieves all info pertaining to a block Id.
       # ! clean_id -> the block ID or URL cleaned : ``str``
       Core.options['cookies'][:token_v2] = @@token_v2
-      Core.options['headers']['x-notion-active-user-header'] = @active_user_header
+      Core.options['headers']['x-notion-active-user-header'] = @@active_user_header
       cookies = Core.options['cookies']
       headers = Core.options['headers']
 
@@ -193,7 +230,7 @@ module NotionAPI
     def extract_view_ids(clean_id, jsonified_record_response)
       jsonified_record_response['block'][clean_id]['value']['view_ids'] || []
     end
-
+    
     def extract_id(url_or_id)
       # ! parse and clean the URL or ID object provided.
       # ! url_or_id -> the block ID or URL : ``str``
@@ -213,5 +250,47 @@ module NotionAPI
         raise ArgumentError, 'Expected a Notion page URL or a page ID. Please consult the documentation for further information.'
       end
     end
+
+    def extract_collection_schema(collection_id, view_id, response = {})
+      # ! retrieve the collection scehma. Useful for 'building' the backbone for a table.
+      # ! collection_id -> the collection ID : ``str``
+      # ! view_id -> the view ID : ``str``
+      cookies = Core.options['cookies']
+      headers = Core.options['headers']
+
+      if response.empty?
+        query_collection_hash = Utils::CollectionViewComponents.query_collection(collection_id, view_id, '')
+
+        request_url = URLS[:GET_COLLECTION]
+        response = HTTParty.post(
+          request_url,
+          body: query_collection_hash.to_json,
+          cookies: cookies,
+          headers: headers
+        )
+        response['recordMap']['collection'][collection_id]['value']['schema']
+      else
+        response['collection'][collection_id]['value']['schema']
+      end
+    end
+    
+    def extract_collection_data(collection_id, view_id)
+      # ! retrieve the collection scehma. Useful for 'building' the backbone for a table.
+      # ! collection_id -> the collection ID : ``str``
+      # ! view_id -> the view ID : ``str``
+      cookies = Core.options['cookies']
+      headers = Core.options['headers']
+
+      query_collection_hash = Utils::CollectionViewComponents.query_collection(collection_id, view_id, '')
+
+      request_url = URLS[:GET_COLLECTION]
+      response = HTTParty.post(
+        request_url,
+        body: query_collection_hash.to_json,
+        cookies: cookies,
+        headers: headers
+      )
+      response['recordMap']
+    end
   end
 end

data/lib/notion_api/notion_types/bulleted_block.rb

@@ -0,0 +1,17 @@
+require_relative "template"
+
+module NotionAPI
+  # Bullet list block: best for an unordered list
+  class BulletedBlock < BlockTemplate
+    @notion_type = "bulleted_list"
+    @type = "bulleted_list"
+
+    def type
+      NotionAPI::BulletedBlock.notion_type
+    end
+
+    class << self
+      attr_reader :notion_type, :type
+    end
+  end
+end

data/lib/notion_api/notion_types/callout_block.rb

@@ -0,0 +1,16 @@
+module NotionAPI
+
+    # same as quote... works similarly to page block
+    class CalloutBlock < BlockTemplate
+      @notion_type = 'callout'
+      @type = 'callout'
+  
+      def type
+        NotionAPI::CalloutBlock.notion_type
+      end
+  
+      class << self
+        attr_reader :notion_type, :type
+      end
+    end
+end

data/lib/notion_api/notion_types/code_block.rb

@@ -0,0 +1,16 @@
+module NotionAPI
+
+    # Code block: used to store code, should be assigned a coding language.
+    class CodeBlock < BlockTemplate
+      @notion_type = 'code'
+      @type = 'code'
+  
+      def type
+        NotionAPI::CodeBlock.notion_type
+      end
+  
+      class << self
+        attr_reader :notion_type, :type
+      end
+    end
+end

data/lib/notion_api/notion_types/collection_view_blocks.rb

@@ -0,0 +1,316 @@
+module NotionAPI
+  # collection views such as tables and timelines.
+  class CollectionView < Core
+    attr_reader :id, :title, :parent_id, :collection_id, :view_id
+
+    @notion_type = "collection_view"
+    @type = "collection_view"
+
+    def type
+      NotionAPI::CollectionView.notion_type
+    end
+
+    class << self
+      attr_reader :notion_type, :type
+    end
+
+    def initialize(id, title, parent_id, collection_id, view_id)
+      @id = id
+      @title = title
+      @parent_id = parent_id
+      @collection_id = collection_id
+      @view_id = view_id
+    end
+
+    def add_row(data)
+      # ! add new row to Collection View table.
+      # ! data -> data to add to table : ``hash``
+
+      cookies = Core.options["cookies"]
+      headers = Core.options["headers"]
+
+      request_id = extract_id(SecureRandom.hex(16))
+      transaction_id = extract_id(SecureRandom.hex(16))
+      space_id = extract_id(SecureRandom.hex(16))
+      new_block_id = extract_id(SecureRandom.hex(16))
+      schema = extract_collection_schema(@collection_id, @view_id)
+      keys = schema.keys
+      col_map = {}
+      keys.map { |key| col_map[schema[key]["name"]] = key }
+
+      request_ids = {
+        request_id: request_id,
+        transaction_id: transaction_id,
+        space_id: space_id,
+      }
+
+      instantiate_row = Utils::CollectionViewComponents.add_new_row(new_block_id)
+      set_block_alive = Utils::CollectionViewComponents.set_collection_blocks_alive(new_block_id, @collection_id)
+      new_block_edited_time = Utils::BlockComponents.last_edited_time(new_block_id)
+      parent_edited_time = Utils::BlockComponents.last_edited_time(@parent_id)
+
+      operations = [
+        instantiate_row,
+        set_block_alive,
+        new_block_edited_time,
+        parent_edited_time,
+      ]
+
+      data.keys.each_with_index do |col_name, j|
+        unless col_map.keys.include?(col_name.to_s); raise ArgumentError, "Column '#{col_name.to_s}' does not exist." end
+        child_component = Utils::CollectionViewComponents.insert_data(new_block_id, col_map[col_name.to_s], data[col_name], schema[col_map[col_name.to_s]]["type"])
+        operations.push(child_component)
+      end
+
+      request_url = URLS[:UPDATE_BLOCK]
+      request_body = build_payload(operations, request_ids)
+      response = HTTParty.post(
+        request_url,
+        body: request_body.to_json,
+        cookies: cookies,
+        headers: headers,
+      )
+
+      unless response.code == 200; raise "There was an issue completing your request. Here is the response from Notion: #{response.body}, and here is the payload that was sent: #{operations}.
+           Please try again, and if issues persist open an issue in GitHub.";       end
+
+      NotionAPI::CollectionViewRow.new(new_block_id, @parent_id, @collection_id, @view_id)
+    end
+
+    def add_property(name, type)
+      # ! add a property (column) to the table.
+      # ! name -> name of the property : ``str``
+      # ! type -> type of the property : ``str``
+      cookies = Core.options["cookies"]
+      headers = Core.options["headers"]
+
+      request_id = extract_id(SecureRandom.hex(16))
+      transaction_id = extract_id(SecureRandom.hex(16))
+      space_id = extract_id(SecureRandom.hex(16))
+
+      request_ids = {
+        request_id: request_id,
+        transaction_id: transaction_id,
+        space_id: space_id,
+      }
+
+      # create updated schema
+      schema = extract_collection_schema(@collection_id, @view_id)
+      schema[name] = {
+        name: name,
+        type: type,
+      }
+      new_schema = {
+        schema: schema,
+      }
+
+      add_collection_property = Utils::CollectionViewComponents.add_collection_property(@collection_id, new_schema)
+
+      operations = [
+        add_collection_property,
+      ]
+
+      request_url = URLS[:UPDATE_BLOCK]
+      request_body = build_payload(operations, request_ids)
+      response = HTTParty.post(
+        request_url,
+        body: request_body.to_json,
+        cookies: cookies,
+        headers: headers,
+      )
+      unless response.code == 200; raise "There was an issue completing your request. Here is the response from Notion: #{response.body}, and here is the payload that was sent: #{operations}.
+           Please try again, and if issues persist open an issue in GitHub.";       end
+
+      true
+    end
+
+    def row(row_id)
+      # ! retrieve a row from a CollectionView Table.
+      # ! row_id -> the ID for the row to retrieve: ``str``
+      clean_id = extract_id(row_id)
+
+      request_body = {
+        pageId: clean_id,
+        chunkNumber: 0,
+        limit: 100,
+        verticalColumns: false,
+      }
+      jsonified_record_response = get_all_block_info(clean_id, request_body)
+
+      i = 0
+      while jsonified_record_response.empty? || jsonified_record_response["block"].empty?
+        return {} if i >= 10
+
+        jsonified_record_response = get_all_block_info(clean_id, request_body)
+        i += 1
+      end
+
+      collection_data = extract_collection_data(@collection_id, @view_id)
+      schema = collection_data["collection"][collection_id]["value"]["schema"]
+      column_mappings = schema.keys
+      column_names = column_mappings.map { |mapping| schema[mapping]["name"] }
+
+      collection_row = CollectionViewRow.new(row_id, @parent_id, @collection_id, @view_id)
+      collection_row.instance_variable_set(:@column_names, column_names)
+      CollectionViewRow.class_eval { attr_reader :column_names }
+
+      row_data = collection_data["block"][collection_row.id]
+      create_singleton_methods_and_instance_variables(collection_row, row_data)
+
+      collection_row
+    end
+
+    def row_ids
+      # ! retrieve all Collection View table rows.
+      clean_id = extract_id(@id)
+
+      request_body = {
+        pageId: clean_id,
+        chunkNumber: 0,
+        limit: 100,
+        verticalColumns: false,
+      }
+
+      jsonified_record_response = get_all_block_info(clean_id, request_body)
+      i = 0
+      while jsonified_record_response.empty? || jsonified_record_response["block"].empty?
+        return {} if i >= 10
+
+        jsonified_record_response = get_all_block_info(clean_id, request_body)
+        i += 1
+      end
+
+      jsonified_record_response["collection_view"][@view_id]["value"]["page_sort"]
+    end
+
+    def rows
+      # ! returns all rows as instantiated class instances.
+      row_id_array = row_ids
+      parent_id = @parent_id
+      collection_id = @collection_id
+      view_id = @view_id
+      collection_data = extract_collection_data(@collection_id, @view_id)
+      schema = collection_data["collection"][collection_id]["value"]["schema"]
+      column_mappings = schema.keys
+      column_names = column_mappings.map { |mapping| schema[mapping]["name"] }
+
+      row_instances = row_id_array.map { |row_id| NotionAPI::CollectionViewRow.new(row_id, parent_id, collection_id, view_id) }
+      clean_row_instances = row_instances.filter { |row| collection_data["block"][row.id] }
+      clean_row_instances.each { |row| row.instance_variable_set(:@column_names, column_names) }
+      CollectionViewRow.class_eval { attr_reader :column_names }
+
+      clean_row_instances.each do |collection_row|
+        row_data = collection_data["block"][collection_row.id]
+        create_singleton_methods_and_instance_variables(collection_row, row_data)
+      end
+      clean_row_instances
+    end
+    def create_singleton_methods_and_instance_variables(row, row_data)
+      # ! creates singleton methods for each property in a CollectionView.
+      # ! row -> the block ID of the 'row' to retrieve: ``str``
+      # ! row_data -> the data corresponding to that row, should be key-value pairs where the keys are the columns: ``hash``
+      collection_data = extract_collection_data(@collection_id, @view_id)
+      schema = collection_data["collection"][collection_id]["value"]["schema"]
+      column_mappings = schema.keys
+      column_hash = {}
+      column_names = column_mappings.map { |mapping| column_hash[mapping] = schema[mapping]["name"].downcase }
+      
+      column_hash.keys.each_with_index do |column, i|
+        # loop over the column names...
+        # set instance variables for each column, allowing the dev to 'read' the column value
+        cleaned_column = column_hash[column].split(" ").join("_").downcase.to_sym
+
+        # p row_data["value"]["properties"][column_mappings[i]], !(row_data["value"]["properties"][column] or row_data["value"]["properties"][column_mappings[i]])
+        if row_data["value"]["properties"].nil? or row_data["value"]["properties"][column].nil?
+          value = ""
+        else
+          value = row_data["value"]["properties"][column][0][0]  
+        end
+
+        row.instance_variable_set("@#{cleaned_column}", value)
+        CollectionViewRow.class_eval { attr_reader cleaned_column }
+        # then, define singleton methods for each column that are used to update the table cell 
+        row.define_singleton_method("#{cleaned_column}=") do |new_value|
+          # neat way to get the name of the currently invoked method...
+          parsed_method = __method__.to_s[0...-1].split("_").join(" ")
+          cookies = Core.options["cookies"]
+          headers = Core.options["headers"]
+
+          request_id = extract_id(SecureRandom.hex(16))
+          transaction_id = extract_id(SecureRandom.hex(16))
+          space_id = extract_id(SecureRandom.hex(16))
+
+          request_ids = {
+            request_id: request_id,
+            transaction_id: transaction_id,
+            space_id: space_id,
+          }
+
+          update_property_value = Utils::CollectionViewComponents.update_property_value(@id, column_hash.key(parsed_method), new_value)
+
+          operations = [
+            update_property_value,
+          ]
+
+          request_url = URLS[:UPDATE_BLOCK]
+          request_body = build_payload(operations, request_ids)
+          response = HTTParty.post(
+            request_url,
+            body: request_body.to_json,
+            cookies: cookies,
+            headers: headers,
+          )
+          unless response.code == 200; raise "There was an issue completing your request. Here is the response from Notion: #{response.body}, and here is the payload that was sent: #{operations}.
+               Please try again, and if issues persist open an issue in GitHub.";end
+          
+          # set the instance variable to the updated value!
+          _ = row.instance_variable_set("@#{__method__.to_s[0...-1]}", new_value)
+          row
+        end
+      end
+    end
+  end
+
+  # class that represents each row in a CollectionView
+  class CollectionViewRow < Core
+    @notion_type = "table_row"
+    @type = "table_row"
+
+    def type
+      NotionAPI::CollectionViewRow.notion_type
+    end
+
+    def inspect
+      "CollectionViewRow - id: #{self.id} - parent id: #{self.parent_id}"
+    end
+
+    class << self
+      attr_reader :notion_type, :type, :parent_id
+    end
+
+    attr_reader :parent_id, :id
+
+    def initialize(id, parent_id, collection_id, view_id)
+      @id = id
+      @parent_id = parent_id
+      @collection_id = collection_id
+      @view_id = view_id
+    end
+  end
+
+  # class that represents a CollectionViewPage, inheriting all properties from CollectionView
+  class CollectionViewPage < CollectionView
+    @notion_type = "collection_view_page"
+    @type = "collection_view_page"
+
+    def type
+      NotionAPI::CollectionViewRow.notion_type
+    end
+
+    class << self
+      attr_reader :notion_type, :type, :parent_id
+    end
+
+    attr_reader :parent_id, :id
+  end
+end