Fix (Attributes): Rescue from problematic dictionaries

speckle_connector/src/convertors/to_native.rb

@@ -48,7 +48,9 @@ module SpeckleConnector
       # @param obj [Object] speckle commit object.
       def receive_commit_object(obj, model_preferences)
         # First create layers on the sketchup before starting traversing
-        create_layers(obj.keys.filter_map { |key| key if key.start_with?('@') }, sketchup_model.layers)
+        filtered_layer_containers = obj.keys.filter_map { |key| key if key.start_with?('@') && key != '@Named Views' }
+        create_layers(filtered_layer_containers, sketchup_model.layers)
+        create_views(obj.filter_map { |key, value| value if key == '@Named Views' }, sketchup_model)
         # Define default commit layer which is the fallback
         default_commit_layer = sketchup_model.layers.layers.find { |layer| layer.display_name == '@Untagged' }
         traverse_commit_object(obj, sketchup_model.layers, default_commit_layer, model_preferences)
@@ -70,6 +72,23 @@ module SpeckleConnector
         create_folder_layers(folder_layer_arrays, folder)
       end
 
+      # @param views [Array] views.
+      # @param sketchup_model [Sketchup::Model] active sketchup model.
+      def create_views(views, sketchup_model)
+        return if views.empty?
+
+        views.first.each do |view|
+          origin = view['origin']
+          target = view['target']
+          origin = SpeckleObjects::Geometry::Point.to_native(origin['x'], origin['y'], origin['z'], origin['units'])
+          target = SpeckleObjects::Geometry::Point.to_native(target['x'], target['y'], target['z'], target['units'])
+          # Set camera position before creating scene on it.
+          my_camera = Sketchup::Camera.new(origin, target, [0, 0, 1], !view['isOrthogonal'], view['lens'])
+          sketchup_model.active_view.camera = my_camera
+          sketchup_model.pages.add(view['name'])
+        end
+      end
+
       # @param headless_layers [Array<String>] headless layer names.
       # @param folder [Sketchup::Layers, Sketchup::LayerFolder] layer folder to create commit layers under it.
       def create_headless_layers(headless_layers, folder)

speckle_connector/src/convertors/to_speckle.rb

@@ -4,9 +4,11 @@ require_relative 'converter'
 require_relative 'base_object_serializer'
 require_relative '../speckle_objects/base'
 require_relative '../speckle_objects/geometry/line'
+require_relative '../speckle_objects/geometry/length'
 require_relative '../speckle_objects/geometry/mesh'
 require_relative '../speckle_objects/other/block_instance'
 require_relative '../speckle_objects/other/block_definition'
+require_relative '../speckle_objects/built_elements/view3d'
 
 module SpeckleConnector
   module Converters
@@ -30,9 +32,48 @@ module SpeckleConnector
         end
         # send only layers that have any object
         base_object_properties = layers.reject { |_layer_name, objects| objects.empty? }
+        add_views(base_object_properties) if sketchup_model.pages.any?
         SpeckleObjects::Base.with_detached_layers(base_object_properties)
       end
 
+      # Add views from pages.
+      # @param base_object_properties [Hash] dynamically attached base object properties.
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def add_views(base_object_properties)
+        views = []
+        sketchup_model.pages.each do |page|
+          cam = page.camera
+          origin = SpeckleObjects::Geometry::Point.new(
+            SpeckleObjects::Geometry.length_to_speckle(cam.eye[0], @units),
+            SpeckleObjects::Geometry.length_to_speckle(cam.eye[1], @units),
+            SpeckleObjects::Geometry.length_to_speckle(cam.eye[2], @units),
+            @units
+          )
+          target = SpeckleObjects::Geometry::Point.new(
+            SpeckleObjects::Geometry.length_to_speckle(cam.target[0], @units),
+            SpeckleObjects::Geometry.length_to_speckle(cam.target[1], @units),
+            SpeckleObjects::Geometry.length_to_speckle(cam.target[2], @units),
+            @units
+          )
+          direction = SpeckleObjects::Geometry::Vector.new(
+            SpeckleObjects::Geometry.length_to_speckle(cam.direction[0], @units),
+            SpeckleObjects::Geometry.length_to_speckle(cam.direction[1], @units),
+            SpeckleObjects::Geometry.length_to_speckle(cam.direction[2], @units),
+            @units
+          )
+          view = SpeckleObjects::BuiltElements::View3d.new(
+            page.name,
+            origin, target, direction, SpeckleObjects::Geometry::Vector.new(0, 0, 1, @units),
+            cam.perspective?, cam.fov, @units, page.name
+          )
+          views.append(view)
+        end
+        base_object_properties['@Named Views'] = views
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+
       # Serialized and traversed information to send batches.
       # @param base [SpeckleObjects::Base] base object to serialize.
       # @return [String, Integer, Array<Object>] base id, total_children_count of base and batches

speckle_connector/src/sketchup_model/dictionary/dictionary_handler.rb

@@ -28,7 +28,10 @@ module SpeckleConnector
           dictionaries.each do |dict_name, entries|
             dict_name = dict_name == 'empty_dictionary_name' ? '' : dict_name
             JSON.parse(entries).each do |key, value|
-              entity.set_attribute(dict_name, key, value)
+              set_attribute(entity, key, value, dict_name)
+            rescue StandardError => e
+              puts("Failed to write key: #{key} value: #{value} to dictionary #{dict_name}")
+              puts(e)
             end
           end
         end

speckle_connector/src/speckle_objects/built_elements/view3d.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../base'
+require_relative '../../speckle_objects/geometry/point'
+require_relative '../../speckle_objects/geometry/vector'
+
+module SpeckleConnector
+  module SpeckleObjects
+    module BuiltElements
+      # View3d object represents scenes on Sketchup.
+      class View3d < Base
+        SPECKLE_TYPE = 'Objects.BuiltElements.View:Objects.BuiltElements.View3D'
+
+        # @param name [String] name of the scene
+        # @param origin [SpeckleObjects::Geometry::Point] origin (eye) of the view.
+        # @param target [SpeckleObjects::Geometry::Point] target of the view.
+        # @param direction [SpeckleObjects::Geometry::Vector] direction of the view from eye to target.
+        # @param up_direction [SpeckleObjects::Geometry::Vector] up direction of the view.
+        # @param is_perspective [Boolean] whether view is perspective or not.
+        # @param lens [Boolean] fov value of the view camera.
+        # @param units [String] units of the camera.
+        # @param application_id [String] application_id of the view.
+        # rubocop:disable Metrics/ParameterLists
+        def initialize(name, origin, target, direction, up_direction,
+                       is_perspective, lens, units, application_id)
+          super(
+            speckle_type: SPECKLE_TYPE,
+            total_children_count: 0,
+            application_id: application_id,
+            id: nil
+          )
+          self[:name] = name
+          self[:origin] = origin
+          self[:target] = target
+          self[:forwardDirection] = direction
+          self[:upDirection] = up_direction
+          self[:isOrthogonal] = !is_perspective
+          self[:lens] = lens
+          self[:units] = units
+        end
+        # rubocop:enable Metrics/ParameterLists
+      end
+    end
+  end
+end