Pass group selection info if only group selected

speckle_connector/src/actions/mapper_selection_changed.rb

@@ -47,11 +47,20 @@ module SpeckleConnector
 
         # Return Direct Shape itself if multiple kinds of element are selected like Edge and Face.
         # OR single type is equal to only direct shape supports.
+        return multiple_supported_selection_info(selection) if supported_entity_count > 1
+
+        # FIXME: Distinguish selection info according to selection elegantly!!!
+        if grouped_by_type.keys.first == Sketchup::ComponentInstance
+          return component_selection_info(selection, source_exist)
+        end
+
+        return group_selection_info(selection) if grouped_by_type.keys.first == Sketchup::Group
+
         if supported_entity_count > 1 ||
            (supported_entity_count == 1 &&
              MAPPER_DIRECT_SHAPE_SUPPORTED_ENTITY_TYPES.include?(grouped_by_type.keys.first))
           if source_exist
-            return direct_shape_selection_info_with_source(state, selection, [])
+            return direct_shape_selection_info_with_source(selection, [])
           else
             return direct_shape_selection_info(selection, source_exist)
           end
@@ -82,6 +91,34 @@ module SpeckleConnector
         mappingMethods: []
       }.freeze
 
+      def multiple_supported_selection_info(selection)
+        {
+          selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+          mappingMethods: ['Direct Shape']
+        }.freeze
+      end
+
+      def component_selection_info(selection, source_exist)
+        if source_exist
+          {
+            selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+            mappingMethods: ['New Revit Family', 'Family Instance']
+          }.freeze
+        else
+          {
+            selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+            mappingMethods: ['New Revit Family']
+          }.freeze
+        end
+      end
+
+      def group_selection_info(selection)
+        {
+          selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+          mappingMethods: ['Direct Shape']
+        }.freeze
+      end
+
       def direct_shape_selection_info(selection, source_exist)
         methods = ['Direct Shape', 'New Revit Family']
         methods.append('Family Instance') if source_exist
@@ -98,9 +135,7 @@ module SpeckleConnector
         }.freeze
       end
 
-      def direct_shape_selection_info_with_source(state, filtered_selection, methods)
-        types = state.speckle_state.speckle_mapper_state.mapper_source.types
-        levels = state.speckle_state.speckle_mapper_state.mapper_source.levels
+      def direct_shape_selection_info_with_source(filtered_selection, methods)
         instances = @selection.grep(Sketchup::ComponentInstance)
         selected_level = instances.find do |i|
           DICTIONARY::SpeckleEntityDictionaryHandler
@@ -112,10 +147,8 @@ module SpeckleConnector
         end
         {
           selection: READER::MapperReader.entities_schema_details(filtered_selection),
-          mappingMethods: ['Direct Shape', 'Family Instance'] + methods,
+          mappingMethods: ['Direct Shape'] + methods,
           categories: Mapper::Category::RevitCategory.to_a,
-          types: types,
-          levels: levels,
           selectedLevelName: selected_level_name
         }.freeze
       end
@@ -128,9 +161,9 @@ module SpeckleConnector
 
         if source_exist
           if grouped_by_verticality.keys.first
-            direct_shape_selection_info_with_source(state, faces, ['Wall'])
+            direct_shape_selection_info_with_source(faces, ['Wall'])
           else
-            direct_shape_selection_info_with_source(state, faces, ['Floor'])
+            direct_shape_selection_info_with_source(faces, ['Floor'])
           end
         else
           if grouped_by_verticality.keys.first
@@ -146,7 +179,7 @@ module SpeckleConnector
 
         if source_exist
           methods = ['Column', 'Beam', 'Pipe', 'Duct']
-          direct_shape_selection_info_with_source(state, edges, methods)
+          direct_shape_selection_info_with_source(edges, methods)
         else
           default_methods = ['Default Column', 'Default Beam', 'Default Pipe', 'Default Duct']
           direct_shape_selection_info_with_default(edges, default_methods)

speckle_connector/src/actions/mapper_source_updated.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'action'
+require_relative '../constants/type_constants'
 require_relative '../mapper/mapper_source'
 require_relative '../speckle_objects/built_elements/revit/revit_element_type'
 
@@ -20,13 +21,15 @@ module SpeckleConnector
       def update_state(state)
         levels = convert_levels(state, @base['@Levels'])
         types = convert_types(@base['@Types'])
+        family_instances = convert_family_instance_types(@base['@Types'])
         mapper_source = Mapper::MapperSource.new(@stream_id, @commit_id, levels, types)
         new_speckle_state = state.speckle_state.with_mapper_source(mapper_source)
         state = state.with_speckle_state(new_speckle_state)
 
         state.with_add_queue('mapperSourceUpdated', @stream_id, [
                                { is_string: false, val: levels.to_json },
-                               { is_string: false, val: types.to_json }
+                               { is_string: false, val: types.to_json },
+                               { is_string: false, val: family_instances.to_json }
                              ])
       end
 
@@ -43,6 +46,27 @@ module SpeckleConnector
         end.compact.to_h
       end
 
+      def convert_family_instance_types(types)
+        family_instance_types = {}
+        types.each do |type, type_elements|
+          next if type_elements.nil? || !type_elements.is_a?(Array) || type == '__closure'
+
+          # skip type if there is no any revit symbol element type
+          symbol_element_types = type_elements.select do |t|
+            t['speckle_type'] == OBJECTS_BUILTELEMENTS_REVIT_REVITSYMBOLELEMENTTYPE &&
+              t['placementType'] == 'OneLevelBased'
+          end
+          next if symbol_element_types.empty?
+
+          elements = type_elements.map do |type_element|
+            SpeckleObjects::BuiltElements::Revit::RevitElementType.to_native(type_element)
+          end
+          elements = elements.group_by { |e| e[:family] }
+          family_instance_types.merge!(elements)
+        end
+        family_instance_types
+      end
+
       def convert_levels(state, levels)
         levels.collect do |level|
           SpeckleObjects::BuiltElements::Level.to_native(state, level, @stream_id)

speckle_connector/src/constants/type_constants.rb

@@ -14,8 +14,10 @@ module SpeckleConnector
   OBJECTS_BUILTELEMENTS_DEFAULT_WALL = 'Objects.BuiltElements.Wall'
   OBJECTS_BUILTELEMENTS_REVIT_WALL = 'Objects.BuiltElements.Wall:Objects.BuiltElements.Revit.RevitWall'
   OBJECTS_BUILTELEMENTS_REVIT_DIRECTSHAPE = 'Objects.BuiltElements.Revit.DirectShape'
+  OBJECTS_BUILTELEMENTS_REVIT_FAMILY_INSTANCE = 'Objects.BuiltElements.Revit.FamilyInstance'
   OBJECTS_BUILTELEMENTS_REVIT_PARAMETER = 'Objects.BuiltElements.Revit.Parameter'
   OBJECTS_BUILTELEMENTS_REVIT_REVITELEMENTTYPE = 'Objects.BuiltElements.Revit.RevitElementType'
+  OBJECTS_BUILTELEMENTS_REVIT_REVITSYMBOLELEMENTTYPE = 'Objects.BuiltElements.Revit.RevitElementType:Objects.BuiltElements.Revit.RevitSymbolElementType'
 
   OBJECTS_GEOMETRY_LINE = 'Objects.Geometry.Line'
   OBJECTS_GEOMETRY_POLYLINE = 'Objects.Geometry.Polyline'

speckle_connector/src/speckle_objects/built_elements/revit/family_instance.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../base'
+require_relative '../../../constants/type_constants'
+
+module SpeckleConnector
+  module SpeckleObjects
+    module BuiltElements
+      module Revit
+        # Family instance for Revit mappings.
+        class FamilyInstance < Base
+          SPECKLE_TYPE = OBJECTS_BUILTELEMENTS_REVIT_FAMILY_INSTANCE
+          READER = SketchupModel::Reader
+          QUERY = SketchupModel::Query
+          DICTIONARY = SketchupModel::Dictionary
+
+          # rubocop:disable Metrics/ParameterLists
+          def initialize(family:, type:, level:, units:, base_point:, application_id: nil)
+            super(
+              speckle_type: SPECKLE_TYPE,
+              total_children_count: 0,
+              application_id: application_id,
+              id: nil
+            )
+            self[:family] = family
+            self[:type] = type
+            self[:level] = level
+            self[:units] = units
+            self[:basePoint] = base_point
+          end
+          # rubocop:enable Metrics/ParameterLists
+        end
+      end
+    end
+  end
+end

speckle_connector/src/speckle_objects/other/block_instance.rb

@@ -6,6 +6,7 @@ require_relative 'block_definition'
 require_relative '../base'
 require_relative '../geometry/bounding_box'
 require_relative '../other/mapped_block_wrapper'
+require_relative '../built_elements/revit/family_instance'
 require_relative '../../sketchup_model/dictionary/base_dictionary_handler'
 require_relative '../../sketchup_model/dictionary/speckle_schema_dictionary_handler'
 require_relative '../../sketchup_model/query/layer'
@@ -121,7 +122,19 @@ module SpeckleConnector
                 application_id: component_instance.persistent_id.to_s
               )
             when 'Family Instance'
-              puts 'not there yet'
+              level = speckle_state.speckle_mapper_state.mapper_source
+                                   .levels.find { |l| l[:name] == speckle_schema['level'] }
+              family = speckle_schema['family']
+              type = speckle_schema['family_type']
+              block_instance['@SpeckleSchema'] = SpeckleObjects::BuiltElements::Revit::FamilyInstance.new(
+                family: family,
+                type: type,
+                level: level,
+                units: units,
+                base_point: SpeckleObjects::Geometry::Point
+                              .from_vertex(component_instance.bounds.min.transform(transformation), units),
+                application_id: component_instance.persistent_id.to_s
+              )
             end
           end
 

speckle_connector/src/speckle_objects/speckle/core/models/model_collection.rb

@@ -103,7 +103,7 @@ module SpeckleConnector
                 return [direct_shape, [entity]]
               end
 
-              if method == 'New Revit Family'
+              if ['New Revit Family', 'Family Instance'].include?(method)
                 _speckle_state, block_instance = SpeckleObjects::Other::BlockInstance.from_component_instance(
                   entity, units, preferences, speckle_state, path: path, &convert
                 )

ui/src/components/Mapper.vue

@@ -171,7 +171,7 @@
               class="pt-0"
               label="Family"
               :disabled="!entitySelected"
-              :items="families"
+              :items="inputFamilies"
               density="compact"
               clearable
               @change="onSelectedFamilyChange"
@@ -282,8 +282,9 @@ import {groupBy} from "@/utils/groupBy";
 import MappingSource from "@/components/MapperSource.vue";
 import {sourceMap} from "@vue/cli-service/lib/config/terserOptions";
 
-global.mapperSourceUpdated = function (streamId, levels, types) {
+global.mapperSourceUpdated = function (streamId, levels, types, familyInstances) {
   console.log(`Mapper source updated for ${streamId}.`)
+  bus.$emit('mapper-source-updated', JSON.stringify(levels), JSON.stringify(types), JSON.stringify(familyInstances))
 }
 
 global.entitySelected = function (selectionParameters) {
@@ -347,7 +348,7 @@ export default {
       entitySelected: false,
       selectedEntityCount: 0,
       selectedEntities: [],
-      allFamilyTypes: {},
+
       familyTypes: [],
       lastSelectedEntity: null,
 
@@ -362,9 +363,14 @@ export default {
       categories: [],
       familyCategories: [],
 
-      families: [],
-      allTypes: {},
+      inputCategories: [],
+      inputFamilies: [],
+      inputFamilyTypes: {},
+
+      // comes from source
+      types: {},
       levels: [],
+      familyInstanceTypes: {}, // comes from source as filtered
 
       mappedEntityCount: 0,
       mappedEntities: [],
@@ -540,6 +546,11 @@ export default {
       else if (this.selectedMethod === 'New Revit Family'){
         this.categorySelectionActive = true
       }
+      else if (this.selectedMethod === 'Family Instance'){
+        this.typeSelectionActive = true
+        this.familySelectionActive = true
+        this.levelSelectionActive = true
+      }
       else if (nativeDefaultMethods.includes(this.selectedMethod)){
         this.typeSelectionActive = false
         this.familySelectionActive = false
@@ -554,58 +565,66 @@ export default {
       }
     },
     getTypesFromSelectedFamily(){
-      if (this.sourceState !== 'Not Set'){
-        this.familyTypes = this.allFamilyTypes[this.selectedFamily]
-        this.selectedFamilyType = this.familyTypes[0].type
-        if (this.selectedFamilyType === null || this.selectedFamilyType === undefined){
+      // There is no sense to set selected family type if method is not selected
+      if (this.selectedMethod){
+        if (this.sourceState !== 'Not Set'){
+          this.familyTypes = this.inputFamilyTypes[this.selectedFamily]
           this.selectedFamilyType = this.familyTypes[0].type
+          if (this.selectedFamilyType === null || this.selectedFamilyType === undefined){
+            this.selectedFamilyType = this.familyTypes[0].type
+          }
+        }
+        if (this.selectedFamily === null || this.selectedFamily === undefined){
+          this.selectedFamily = this.inputFamilies[0]
+        }
+        if (this.familyTypes === null ||this.familyTypes === undefined){
+          this.familyTypes = this.inputFamilyTypes[this.selectedFamily]
         }
       }
-      if (this.selectedFamily === null || this.selectedFamily === undefined){
-        this.selectedFamily = this.families[0]
-      }
-      if (this.familyTypes === null ||this.familyTypes === undefined){
-        this.familyTypes = this.allFamilyTypes[this.selectedFamily]
-      }
-
     },
     getFamiliesFromSelectedMethod(){
       switch (this.selectedMethod) {
         case 'Floor':
-          this.families = Object.keys(this.allTypes['Floors']);
-          this.allFamilyTypes = this.allTypes['Floors']
+          this.inputFamilies = Object.keys(this.types['Floors']);
+          this.inputFamilyTypes = this.types['Floors']
           break;
         case 'Wall':
-          this.families = Object.keys(this.allTypes['Walls']);
-          this.allFamilyTypes = this.allTypes['Walls']
+          this.inputFamilies = Object.keys(this.types['Walls']);
+          this.inputFamilyTypes = this.types['Walls']
           break;
         case 'Column':
-          this.families = Object.keys(this.allTypes['Columns']);
-          this.allFamilyTypes = this.allTypes['Columns']
+          this.inputFamilies = Object.keys(this.types['Columns']);
+          this.inputFamilyTypes = this.types['Columns']
           break;
         case 'Beam':
-          this.families = Object.keys(this.allTypes['Beams']);
-          this.allFamilyTypes = this.allTypes['Beams']
+          this.inputFamilies = Object.keys(this.types['Beams']);
+          this.inputFamilyTypes = this.types['Beams']
           break;
         case 'Pipe':
-          this.families = Object.keys(this.allTypes['Piping System']);
-          this.allFamilyTypes = this.allTypes['Piping System']
+          this.inputFamilies = Object.keys(this.types['Piping System']);
+          this.inputFamilyTypes = this.types['Piping System']
           break;
         case 'Duct':
-          this.families = Object.keys(this.allTypes['Duct System']);
-          this.allFamilyTypes = this.allTypes['Duct System']
+          this.inputFamilies = Object.keys(this.types['Duct System']);
+          this.inputFamilyTypes = this.types['Duct System']
+          break;
+        case 'Family Instance':
+          this.inputFamilies = Object.keys(this.familyInstanceTypes);
+          this.inputFamilyTypes = this.familyInstanceTypes
           break;
         default:
           break;
       }
-      if (this.selectedFamily === null || this.selectedFamily === undefined){
-        this.selectedFamily = this.families[0]
-      }
-      if (this.sourceState === 'Set'){
+      if (this.selectedMethod){
+        if (this.selectedFamily === null || this.selectedFamily === undefined){
+          this.selectedFamily = this.inputFamilies[0]
+        }
         if (this.selectedLevel === null || this.selectedLevel === undefined){
           this.selectedLevel = this.levels[0].name
         }
       }
+      console.log(this.selectedFamily, "selectedFamily after")
+      console.log(this.selectedLevel, "selectedLevel after")
     },
     hideOptionalMappingInputs(){
       this.categorySelectionActive = false
@@ -633,8 +652,6 @@ export default {
       this.selectedLevel = null
       this.selectedFamily = null
       this.selectedFamilyType = null
-      this.allTypes = null
-      this.familyTypes = null
     },
     getSelectionTableData(){
       let groupByClass = groupBy('entityType')
@@ -826,16 +843,11 @@ export default {
       this.selectedFamily = null
       this.selectedFamilyType = null
       this.selectedLevel = null
-      this.familyTypes = null
-      this.levels = null
       this.availableMethods = null
-      this.allTypes = null
     },
     getDataFromSelection(selectionParameters){
       this.availableMethods = selectionParameters.mappingMethods
       this.selectedEntities = selectionParameters.selection
-      this.allTypes = selectionParameters.types
-      this.levels = selectionParameters.levels
       this.selectedLevel = selectionParameters.selectedLevelName
     },
     updateStatesFromSelectionData(){
@@ -857,6 +869,13 @@ export default {
       this.familyCategories = initPars.familyCategories
     })
 
+    bus.$on('mapper-source-updated', async (levels, types, familyInstances) => {
+      // Parse data to json object
+      this.familyInstanceTypes = JSON.parse(familyInstances)
+      this.levels = JSON.parse(levels)
+      this.types = JSON.parse(types)
+    })
+
     bus.$on('entities-selected', async (selectionParameters) => {
       // Parse data to json object
       const selectionPars = JSON.parse(selectionParameters)