Do not check speckle_type from level anymore (#400)

* Normalize plane axis always

* measure based fix

* backward compatible arcs without measures

.github/workflows/build.yml

@@ -31,8 +31,6 @@ jobs:
 
       - name: Install GitVersion
         uses: gittools/actions/gitversion/setup@v3.0.0
-        with:
-          versionSpec: "5.x"
 
       - name: Determine Version
         id: gitversion

GitVersion.yml

@@ -1,18 +1,11 @@
+workflow: GitFlow/v1
 next-version: 3.0.0
-mode: ContinuousDeployment
-assembly-informational-format: "{Major}.{Minor}.{Patch}-{PreReleaseTag}"
+mode: ManualDeployment
 branches:
   main:
-    regex: ^main$
-    tag: rc
+    label: rc
   develop:
-    regex: ^development$
-    tag: dev
-  pull-request:
-    tag: pr
-  beta:
     regex: ^dui3/alpha$
-    tag: beta
-    source-branches:
-      - develop
-      - main
+    label: beta
+  unknown:
+    increment: None

README.md

@@ -115,6 +115,20 @@ You can now open up the repo in VS Code or you can use JetBrains' tools RubyMine
 
 If you will use VS Code, make sure you've installed the Ruby extension for VS Code.
 
+#### RubyMine
+
+To debug: 
+- Add configuration as **'Ruby remote debug'**
+  - Remote host: localhost
+  - Remote port: 7000
+  - Remote root folder: <repo_path>
+  - Local port: 26162
+  - Local root folder: <repo_path>
+- Run below script
+
+      bundle exec skippy sketchup:debug 2024
+- When sketchup opened, click Debug button on RubyMine
+
 ### Loading the Speckle Connector Plugin
 
 1. Find already prepared `speckle_connector_3_loader.rb` file on the `_tools`

speckle_connector_3/src/actions/base_actions/add_receive_model_card.rb

@@ -17,20 +17,26 @@ module SpeckleConnector3
       def self.update_state(state, resolve_id, data)
         model_card_id = data['modelCardId']
         account_id = data['accountId']
+        workspace_id = data['workspaceId']
         project_id = data['projectId']
         model_id = data['modelId']
         project_name = data['projectName']
         model_name = data['modelName']
         expired = data['expired']
         selected_version_id = data['selectedVersionId']
+        selected_version_source_app = data['selectedVersionSourceApp']
+        selected_version_user_id = data['selectedVersionUserId']
         latest_version_id = data['latestVersionId']
+        latest_version_source_app = data['latestVersionSourceApp']
+        latest_version_user_id = data['latestVersionUserId']
         has_dismissed_update_warning = data['hasDismissedUpdateWarning']
         baked_object_ids = data['bakedObjectIds'].nil? ? nil : data['bakedObjectIds'].values
 
-        receive_card = Cards::ReceiveCard.new(model_card_id, account_id,
+        receive_card = Cards::ReceiveCard.new(model_card_id, account_id, workspace_id,
                                               project_id, model_id,
                                               project_name, model_name,
-                                              selected_version_id, latest_version_id,
+                                              selected_version_id, selected_version_source_app, selected_version_user_id,
+                                              latest_version_id, latest_version_source_app, latest_version_user_id,
                                               has_dismissed_update_warning, expired, baked_object_ids)
         SketchupModel::Dictionary::ModelCardDictionaryHandler
           .save_receive_card_to_model(receive_card, state.sketchup_state.sketchup_model)

speckle_connector_3/src/actions/base_actions/add_send_model_card.rb

@@ -22,6 +22,7 @@ module SpeckleConnector3
         send_card = Cards::SendCard.new(
           data['modelCardId'],
           data['accountId'],
+          data['workspaceId'],
           data['projectId'],
           data['projectName'],
           data['modelId'],

speckle_connector_3/src/actions/base_actions/get_document_state.rb

@@ -21,6 +21,7 @@ module SpeckleConnector3
           send_card = Cards::SendCard.new(
             id,
             card['account_id'],
+            card['workspace_id'],
             card['project_id'],
             card['project_name'],
             card['model_id'],
@@ -35,6 +36,7 @@ module SpeckleConnector3
           {
             modelCardId: send_card.model_card_id,
             accountId: send_card.account_id,
+            workspaceId: send_card.workspace_id,
             projectId: send_card.project_id,
             modelId: send_card.model_id,
             sendFilter: send_card.send_filter,
@@ -49,9 +51,11 @@ module SpeckleConnector3
 
         # TODO: CONVERTER_V2: Extract into new actions
         receive_cards = receive_cards_hash.collect do |id, card|
-          receive_card = Cards::ReceiveCard.new(id, card['account_id'], card['project_id'], card['model_id'],
+          receive_card = Cards::ReceiveCard.new(id, card['account_id'], card['workspace_id'], card['project_id'], card['model_id'],
                                                 card['project_name'], card['model_name'], card['selected_version_id'],
-                                                card['latest_version_id'], card['has_dismissed_update_warning'],
+                                                card['selected_version_source_app'], card['selected_version_user_id'],
+                                                card['latest_version_id'], card['latest_version_source_app'],
+                                                card['latest_version_user_id'], card['has_dismissed_update_warning'],
                                                 card['expired'], card['baked_object_ids'])
 
           new_speckle_state = state.speckle_state.with_receive_card(receive_card)
@@ -59,12 +63,17 @@ module SpeckleConnector3
           {
             modelCardId: receive_card.model_card_id,
             accountId: receive_card.account_id,
+            workspaceId: receive_card.workspace_id,
             projectId: receive_card.project_id,
             modelId: receive_card.model_id,
             projectName: receive_card.project_name,
             modelName: receive_card.model_name,
             selectedVersionId: receive_card.selected_version_id,
+            selectedVersionSourceApp: receive_card.selected_version_source_app,
+            selectedVersionUserId: receive_card.selected_version_user_id,
             latestVersionId: receive_card.latest_version_id,
+            latestVersionSourceApp: receive_card.latest_version_source_app,
+            latestVersionUserId: receive_card.latest_version_user_id,
             hasDismissedUpdateWarning: receive_card.has_dismissed_update_warning,
             expired: receive_card.expired,
             bakedObjectIds: receive_card.baked_object_ids,

speckle_connector_3/src/actions/send_actions/after_send_objects.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+require_relative '../../convertors/to_native'
+require_relative '../../convertors/to_native_v2'
+
+module SpeckleConnector3
+  module Actions
+    # After objects send to server.
+    class AfterSendObjects < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id, model_card_id, referenced_object_id)
+        model_card = state.speckle_state.send_cards[model_card_id]
+        account = Accounts.get_account_by_id(model_card.account_id)
+        args = {
+            modelCardId: model_card_id,
+            projectId: model_card.project_id,
+            modelId: model_card.model_id,
+            token: account['token'],
+            serverUrl: account['serverInfo']['url'],
+            accountId: model_card.account_id,
+            message: model_card.message,
+            referencedObjectId: referenced_object_id,
+            sendConversionResults: state.speckle_state.conversion_results[model_card_id]
+        }
+
+        after_send_object_js_script = "sendBinding.emit('createVersionViaBrowser', #{args.to_json})"
+        state = state.with_add_queue_js_command('createVersionViaBrowser', after_send_object_js_script)
+
+        resolve_js_script = "sendBinding.receiveResponse('#{resolve_id}')"
+        state.with_add_queue_js_command('afterSendObject', resolve_js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/send_actions/send.rb

@@ -18,6 +18,7 @@ module SpeckleConnector3
       def self.update_state(state, resolve_id, model_card_id)
         # Set active path always to model to be safe always. Later we can address it
         state.sketchup_state.sketchup_model.active_path = nil
+        units = Converters::SKETCHUP_UNITS[state.sketchup_state.length_units]
         model_card = state.speckle_state.send_cards[model_card_id]
         unless model_card.send_filter.selected_object_ids.any?
           resolve_js_script = "sendBinding.receiveResponse('#{resolve_id}')"
@@ -35,7 +36,7 @@ module SpeckleConnector3
         end
 
         unpacked_entities = SketchupModel::Definitions::DefinitionManager
-                            .new(Converters::SKETCHUP_UNITS[state.sketchup_state.length_units])
+                            .new(units)
                             .unpack_entities(entities)
 
         unpacked_materials = SketchupModel::Materials::MaterialManager.new.unpack_materials(entities)
@@ -50,6 +51,7 @@ module SpeckleConnector3
         base[:instanceDefinitionProxies] = unpacked_entities.instance_definition_proxies
         base[:renderMaterialProxies] = unpacked_materials
         base[:colorProxies] = unpacked_colors
+        base[:units] = units
 
         id, batches, refs = converter.serialize(base, state.user_state.preferences)
         new_speckle_state = new_speckle_state.with_object_references(model_card.project_id, refs)
@@ -62,22 +64,44 @@ module SpeckleConnector3
 
         resolve_js_script = "sendBinding.receiveResponse('#{resolve_id}')"
         state = state.with_add_queue_js_command('send', resolve_js_script)
-        args = {
-          modelCardId: model_card_id,
-          projectId: model_card.project_id,
-          modelId: model_card.model_id,
-          token: account['token'],
-          serverUrl: account['serverInfo']['url'],
-          accountId: model_card.account_id,
-          message: model_card.message,
-          sendConversionResults: converter.conversion_results,
-          sendObject: {
-            id: id,
-            batches: batches
+        # args = {
+        #   modelCardId: model_card_id,
+        #   projectId: model_card.project_id,
+        #   modelId: model_card.model_id,
+        #   token: account['token'],
+        #   serverUrl: account['serverInfo']['url'],
+        #   accountId: model_card.account_id,
+        #   message: model_card.message,
+        #   sendConversionResults: converter.conversion_results,
+        #   sendObject: {
+        #     id: id,
+        #     batches: batches
+        #   }
+        # }
+        # js_script = "sendBinding.emit('sendViaBrowser', #{args.to_json})"
+        # state.with_add_queue_js_command('sendViaBrowser', js_script)
+
+        # store conversion results in state to pick up later
+        new_speckle_state = state.speckle_state.with_conversion_results(model_card_id, converter.conversion_results)
+        state = state.with_speckle_state(new_speckle_state)
+
+        total_batch_count = batches.count
+        batches.each_with_index do |batch, i|
+          current_batch = i + 1
+          args = {
+            modelCardId: model_card_id,
+            projectId: model_card.project_id,
+            token: account['token'],
+            serverUrl: account['serverInfo']['url'],
+            batch: batch,
+            currentBatch:current_batch,
+            totalBatch: total_batch_count,
+            referencedObjectId: id
           }
-        }
-        js_script = "sendBinding.emit('sendViaBrowser', #{args.to_json})"
-        state.with_add_queue_js_command('sendViaBrowser', js_script)
+          js_script = "sendBinding.emit('sendBatchViaBrowser', #{args.to_json})"
+          state = state.with_add_queue_js_command("sendBatchViaBrowser_#{current_batch}", js_script)
+        end
+        state
       end
     end
   end

speckle_connector_3/src/cards/card.rb

@@ -24,14 +24,18 @@ module SpeckleConnector3
       # @return [String] model name of the card.
       attr_reader :model_name
 
+      # @return [String] workspace id of the card.
+      attr_reader :workspace_id
+
       # @return [Boolean] card is valid or not.
       attr_reader :valid
 
       # rubocop:disable Metrics/ParameterLists
-      def initialize(model_card_id, account_id, project_id, project_name, model_id, model_name)
+      def initialize(model_card_id, account_id, workspace_id, project_id, project_name, model_id, model_name)
         super()
         @model_card_id = model_card_id
         @account_id = account_id
+        @workspace_id = workspace_id
         @project_id = project_id
         @project_name = project_name
         @model_id = model_id
@@ -39,6 +43,7 @@ module SpeckleConnector3
         @valid = true
         self[:model_card_id] = model_card_id
         self[:account_id] = account_id
+        self[:workspace_id] = workspace_id
         self[:project_id] = project_id
         self[:project_name] = project_name
         self[:model_id] = model_id

speckle_connector_3/src/cards/receive_card.rb

@@ -14,9 +14,21 @@ module SpeckleConnector3
       # @return [String] selected version id to receive
       attr_reader :selected_version_id
 
+      # @return [String] selected version source app
+      attr_reader :selected_version_source_app
+
+      # @return [String] selected version user id
+      attr_reader :selected_version_user_id
+
       # @return [String] latest version id to receive
       attr_reader :latest_version_id
 
+      # @return [String] latest version source app
+      attr_reader :latest_version_source_app
+
+      # @return [String] latest version user id
+      attr_reader :latest_version_user_id
+
       # @return [Boolean] whether new version notification is dismissed or not
       attr_reader :has_dismissed_update_warning
 
@@ -36,32 +48,45 @@ module SpeckleConnector3
       def initialize(
         model_card_id,
         account_id,
+        workspace_id,
         project_id,
         model_id,
         project_name,
         model_name,
         selected_version_id,
+        selected_version_source_app,
+        selected_version_user_id,
         latest_version_id,
+        latest_version_source_app,
+        latest_version_user_id,
         has_dismissed_update_warning,
         expired,
         baked_object_ids = nil
       )
-        super(model_card_id, account_id, project_id, project_name, model_id, model_name)
+        super(model_card_id, account_id, workspace_id, project_id, project_name, model_id, model_name)
         @selected_version_id = selected_version_id
+        @selected_version_source_app = selected_version_source_app
+        @selected_version_user_id = selected_version_user_id
         @latest_version_id = latest_version_id
+        @latest_version_source_app = latest_version_source_app
+        @latest_version_user_id = latest_version_user_id
         @has_dismissed_update_warning = has_dismissed_update_warning
         @baked_object_ids = baked_object_ids
-        self[:selected_version_id] = selected_version_id
-        self[:has_dismissed_update_warning] = has_dismissed_update_warning
-        self[:latest_version_id] = latest_version_id
-        self[:model_name] = model_name
-        self[:project_name] = project_name
-        self[:expired] = expired
-        self[:baked_object_ids] = @baked_object_ids
         @expired = expired
         @model_name = model_name
         @project_name = project_name
         @type_discriminator = 'ReceiverModelCard'
+        self[:selected_version_id] = selected_version_id
+        self[:selected_version_source_app] = selected_version_source_app
+        self[:selected_version_user_id] = selected_version_user_id
+        self[:has_dismissed_update_warning] = has_dismissed_update_warning
+        self[:latest_version_id] = latest_version_id
+        self[:latest_version_source_app] = latest_version_source_app
+        self[:latest_version_user_id] = latest_version_user_id
+        self[:model_name] = model_name
+        self[:project_name] = project_name
+        self[:expired] = expired
+        self[:baked_object_ids] = @baked_object_ids
         self[:type_discriminator] = @type_discriminator
       end
       # rubocop:enable Metrics/ParameterLists

speckle_connector_3/src/cards/send_card.rb

@@ -26,6 +26,7 @@ module SpeckleConnector3
       def initialize(
         model_card_id,
         account_id,
+        workspace_id,
         project_id,
         project_name,
         model_id,
@@ -34,7 +35,7 @@ module SpeckleConnector3
         send_filter,
         send_settings
       )
-        super(model_card_id, account_id, project_id, project_name, model_id, model_name)
+        super(model_card_id, account_id, workspace_id, project_id, project_name, model_id, model_name)
         @send_filter = send_filter
         @send_settings = send_settings
         @latest_created_version_id = latest_created_version_id

speckle_connector_3/src/convertors/to_native_v2.rb

@@ -504,7 +504,7 @@ module SpeckleConnector3
       def create_levels(state, speckle_object)
         level = speckle_object['level']
         return state if level.nil?
-        return state unless level['speckle_type'].include?('Objects.BuiltElements.Level')
+        # return state unless level['speckle_type'].include?('Objects.BuiltElements.Level')
 
         level_name = level['name'] || level['id']
         is_exist = @entities_to_fill.grep(Sketchup::SectionPlane).any? { |sp| sp.name == level_name }

speckle_connector_3/src/preferences/preferences.rb

@@ -18,6 +18,11 @@ module SpeckleConnector3
 
     # @param sketchup_model [Sketchup::Model] active model.
     def self.read_preferences(sketchup_model)
+      unless File.exist?(SPECKLE_CONFIG_DB_PATH)
+        File.new(SPECKLE_CONFIG_DB_PATH, "w")
+        db = Sqlite3::Database.new(SPECKLE_CONFIG_DB_PATH)
+        create_objects_table(db)
+      end
       db = Sqlite3::Database.new(SPECKLE_CONFIG_DB_PATH)
       user_preferences = validate_user_preferences(db)
       model_preferences = validate_model_preferences(sketchup_model)
@@ -29,6 +34,17 @@ module SpeckleConnector3
       )
     end
 
+    # Creates the 'objects' table in the database if it doesn't already exist.
+    # @param db [Sqlite3::Database] the SQLite3 database instance.
+    def self.create_objects_table(db)
+      db.exec <<-SQL
+    CREATE TABLE IF NOT EXISTS objects (
+      hash TEXT PRIMARY KEY,
+      content TEXT
+    );
+  SQL
+    end
+
     # Whether row data is complete with preference or not.
     # It is useful for backward compatibility, when we add new preferences it should be reset when user initialize it.
     def self.data_complete?(row_data)

speckle_connector_3/src/speckle_objects/geometry/arc.rb

@@ -18,21 +18,24 @@ module SpeckleConnector3
           plane = arc['plane']
           units = arc['units']
           origin = Point.to_native(plane['origin']['x'], plane['origin']['y'], plane['origin']['z'], units)
-          normal = Vector.to_native(plane['normal']['x'], plane['normal']['y'], plane['normal']['z'], units)
-          x_axis = Vector.to_native(plane['xdir']['x'], plane['xdir']['y'], plane['xdir']['z'], units)
+          start_point = Point.to_native(arc['startPoint']['x'], arc['startPoint']['y'], arc['startPoint']['z'], units)
+          end_point = Point.to_native(arc['endPoint']['x'], arc['endPoint']['y'], arc['endPoint']['z'], units)
+          normal = Vector.to_native(plane['normal']['x'], plane['normal']['y'], plane['normal']['z'], units).normalize
+          x_axis = Vector.to_native(plane['xdir']['x'], plane['xdir']['y'], plane['xdir']['z'], units).normalize
           radius = Geometry.length_to_native(arc['radius'], units)
-          start_angle = arc['startAngle']
-          end_angle = arc['endAngle']
 
-          # Normalize angles to range 0 to 2π
-          start_angle %= 2 * Math::PI
-          end_angle %= 2 * Math::PI
+          start_vector = (start_point - origin).normalize
+          end_vector = (end_point - origin).normalize
 
-          # Ensure start angle is less than end angle for proper drawing
-          if start_angle > end_angle
-            end_angle += 2 * Math::PI
+          start_angle = Math.atan2(start_vector.cross(normal).dot(x_axis), start_vector.dot(x_axis))
+          end_angle = Math.atan2(end_vector.cross(normal).dot(x_axis), end_vector.dot(x_axis))
+
+          measure = arc['measure'] # this is in radians!
+          if measure # for backward compatibilty
+            end_angle = start_angle + measure
+          else
+            end_angle += 2 * Math::PI if end_angle < start_angle
           end
-
           edges = entities.add_arc(origin, x_axis, normal, radius, start_angle, end_angle)
           edges.each { |edge| edge.layer = layer }
           return state, edges

speckle_connector_3/src/states/speckle_state.rb

@@ -17,6 +17,9 @@ module SpeckleConnector3
       # @return [Immutable::Hash{String=>Cards::ReceiveCard}] receive cards.
       attr_reader :receive_cards
 
+      # @return [Immutable::Hash{String=>Array<UiData::Report::ConversionResult>}] receive cards.
+      attr_reader :conversion_results
+
       # @return [Immutable::Hash{String=>Immutable::Hash{String=>SpeckleObjects::ObjectReference}}] object references that sent before server.
       attr_reader :object_references_by_project
 
@@ -70,6 +73,7 @@ module SpeckleConnector3
         @definitions = Immutable::EmptyHash
         @send_cards = Immutable::EmptyHash
         @receive_cards = Immutable::EmptyHash
+        @conversion_results = Immutable::EmptyHash
         @relation = Relations::ManyToOneRelation.new
         @speckle_mapper_state = SpeckleMapperState.new
       end
@@ -218,6 +222,16 @@ module SpeckleConnector3
         with(:@object_references_by_project => object_references_by_project.put(project_id, new_project_references))
       end
 
+      def with_conversion_results(model_card_id, results)
+        new_conversion_results = conversion_results.put(model_card_id, results)
+        with(:@conversion_results => new_conversion_results)
+      end
+
+      def without_conversion_results(model_card_id)
+        new_conversion_results = conversion_results.delete(model_card_id)
+        with(:@conversion_results => new_conversion_results)
+      end
+
       def invalid_streams
         speckle_entities.collect do |_id, speckle_entity|
           speckle_entity.invalid_stream_ids

speckle_connector_3/src/ui/bindings/send_binding.rb

@@ -2,6 +2,7 @@
 
 require_relative 'binding'
 require_relative '../../actions/send_actions/send'
+require_relative '../../actions/send_actions/after_send_objects'
 require_relative '../../actions/base_actions/get_send_filters'
 require_relative '../../actions/base_actions/get_send_settings'
 require_relative '../../actions/base_actions/update_send_filter'
@@ -17,7 +18,8 @@ module SpeckleConnector3
           send: Commands::ActionCommand.new(@app, self, Actions::Send),
           getSendFilters: Commands::ActionCommand.new(@app, self, Actions::GetSendFilters),
           getSendSettings: Commands::ActionCommand.new(@app, self, Actions::GetSendSettings),
-          updateSendFilter: Commands::ActionCommand.new(@app, self, Actions::UpdateSendFilter)
+          updateSendFilter: Commands::ActionCommand.new(@app, self, Actions::UpdateSendFilter),
+          afterSendObjects: Commands::ActionCommand.new(@app, self, Actions::AfterSendObjects)
         }.freeze
       end
     end

speckle_connector_3/src/ui/sketchup_ui.rb

@@ -5,7 +5,7 @@ module SpeckleConnector3
     # An interface to Sketchup user interface. This object controls the menu `Extensions->Speckle` in Sketchup's menu,
     # the Speckle toolbar and sending message to the user via Sketchup.
     class SketchupUi
-      MENU_TITLE = 'Speckle'
+      MENU_TITLE = 'Speckle Beta'
       BEFORE_NEVER_SHOWN = -1
 
       # @return [Sketchup::Menu] the menu of the Speckle