113 feature configue exclusion of building amenities (#114)

* Implement known features configuration

* Updated changelog

* update secrets baseline

Author: clint156

.secrets.baseline

@@ -136,7 +136,7 @@
         "filename": "driven/uiucadapters/wayfindingadapter.go",
         "hashed_secret": "abd4b25cafb785cdf391edc04f82d8af45e1405c",
         "is_verified": false,
-        "line_number": 41
+        "line_number": 42
       }
     ],
     "driver/web/adapter.go": [
@@ -172,5 +172,5 @@
       }
     ]
   },
-  "generated_at": "2024-06-26T14:32:05Z"
+  "generated_at": "2024-11-04T17:23:04Z"
 }

CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## UnReleased - 2024-11-04
+### Changed
+- Pull a list of all known building features from the database. Use this to filter out any that we do not want to display in the app on the building details panel as well as merge groups of some feature codes into a single feature.
+
 ## [2.11.0] - 2024-09-24
 ### Changed
 - Building feature list is now a compact list of feature names paired with floors they exist on to make is easier to use for display and floorplan linking in the app

core/apis_client.go

@@ -252,7 +252,7 @@ func newAppClient(app *Application) appClient {
 	client.ContactAdapter = uiucadapters.NewUIUCContactAdapter()
 	client.LaundryAdapter = uiucadapters.NewCSCLaundryAdapter(laundryAssets)
 	client.Courseadapter = uiucadapters.NewCourseAdapter()
-	client.LocationAdapter = uiucadapters.NewUIUCWayFinding()
+	client.LocationAdapter = uiucadapters.NewUIUCWayFinding(&app.AppBLdgFeatures)
 	client.SuccessTeamAdapter = uiucadapters.NewSuccessTeamAdapter()
 	return client
 }

core/apis_shared.go

@@ -32,3 +32,8 @@ func (a appShared) getExample(orgID string, appID string, id string) (*model.Exa
 func newAppShared(app *Application) appShared {
 	return appShared{app: app}
 }
+
+// getBuildingFeatures returns all building features
+func (a appShared) getBuildingFeatures() ([]model.AppBuildingFeature, error) {
+	return a.app.storage.LoadAppBuildingFeatures()
+}

core/application.go

@@ -49,7 +49,8 @@ type Application struct {
 	System  System  // expose to the drivers adapters
 	shared  Shared
 
-	CampusBuildings model.CachedBuildings //caches a list of all campus building data
+	CampusBuildings model.CachedBuildings               //caches a list of all campus building data
+	AppBLdgFeatures map[string]model.AppBuildingFeature //caches the configured set of building features
 
 	AppointmentAdapters map[string]Appointments //expose to the different vendor specific appointment adapters
 
@@ -113,6 +114,15 @@ func NewApplication(version string, build string,
 	application.shared = newAppShared(&application)
 	application.eventsLogic = newAppEventsLogic(&application, eventsBBAdapter, geoBBAdapter, *logger)
 
+	bldfeatures, blderr := application.shared.getBuildingFeatures()
+	if blderr != nil {
+
+	}
+	application.AppBLdgFeatures = make(map[string]model.AppBuildingFeature)
+	for _, bf := range bldfeatures {
+		application.AppBLdgFeatures[bf.CampusCode] = bf
+	}
+
 	_, err := application.Client.GetBuildings()
 	if err != nil {
 		//set to one day ago to force a retry and refresh

core/interfaces.go

@@ -94,6 +94,7 @@ type System interface {
 // Shared exposes shared APIs for other interface implementations
 type Shared interface {
 	getExample(orgID string, appID string, id string) (*model.Example, error)
+	getBuildingFeatures() ([]model.AppBuildingFeature, error)
 }
 
 // EventsBBAdapter is used by core to communicate with the events BB
@@ -153,6 +154,8 @@ type Storage interface {
 
 	FindLegacyLocationItems() ([]model.LegacyLocation, error)
 	InsertLegacyLocationItem(items model.LegacyLocation) error
+
+	LoadAppBuildingFeatures() ([]model.AppBuildingFeature, error)
 }
 
 // StorageListener represents storage listener

core/model/appbuildingfeatures.go

@@ -0,0 +1,33 @@
+// Copyright 2022 Board of Trustees of the University of Illinois.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package model
+
+import (
+	"github.com/rokwire/logging-library-go/v2/logutils"
+)
+
+const (
+	//TypeAppBuildingFeature type
+	TypeAppBuildingFeature logutils.MessageDataType = "application building feature"
+)
+
+// AppBuildingFeature represents the configured features for campus buildings
+type AppBuildingFeature struct {
+	CampusName string `json:"campus_name" bson:"campus_name"`
+	CampusCode string `json:"campus_code" bson:"campus_code"`
+	AppName    string `json:"app_name" bson:"app_name"`
+	AppCode    string `json:"app_code" bson:"app_code"`
+	ShowInApp  bool   `json:"show_in_app" bson:"show_in_app"`
+}

core/model/uiuc/buildingdata.go

@@ -143,7 +143,7 @@ func NewFloorPlan(fp CampusFloorPlan) *model.FloorPlan {
 
 // NewBuilding creates a wayfinding.Building instance from a campusBuilding,
 // including all active entrances for the building
-func NewBuilding(bldg CampusBuilding) *model.Building {
+func NewBuilding(bldg CampusBuilding, knownFeatures *map[string]model.AppBuildingFeature) *model.Building {
 	newBldg := model.Building{ID: bldg.UUID, Name: bldg.Name, ImageURL: bldg.ImageURL, Address1: bldg.Address1, Address2: bldg.Address2,
 		FullAddress: bldg.FullAddress, City: bldg.City, ZipCode: bldg.ZipCode, State: bldg.State, Latitude: bldg.Latitude, Longitude: bldg.Longitude, Number: bldg.Number}
 	newBldg.Entrances = make([]model.Entrance, 0)
@@ -158,21 +158,27 @@ func NewBuilding(bldg CampusBuilding) *model.Building {
 
 	for _, n := range bldg.Features {
 
-		val, ok := featuredata[n.EQIndicator]
+		//is this feature a known feature
+		kf := *knownFeatures
+		knownFeature, ok := kf[n.EQIndicator]
 		if ok {
-			if !slices.Contains(val.Floors, n.FoundOnFloor) {
-				val.Floors = append(val.Floors, n.FoundOnFloor)
-				featuredata[n.EQIndicator] = val
-			}
+			if knownFeature.ShowInApp {
+				//does featuredata already contain an element with the current EQIndicator as a key
+				newKey := knownFeature.AppCode
+				newName := knownFeature.AppName
+				addFeatureToList(newKey, newName, n.FoundOnFloor, &featuredata)
 
+			}
 		} else {
-			var floors = make([]string, 1)
-			floors[0] = n.FoundOnFloor
-			fme := model.FeatureMapEntry{Name: n.Name, Floors: floors}
-			featuredata[n.EQIndicator] = fme
+			//feature is not in the list of supported features, so add it.
+			//treat non-existent as supported
+			//does featuredata already contain an element with the current EQIndicator as a keuy
+			addFeatureToList(n.EQIndicator, n.Name, n.FoundOnFloor, &featuredata)
+
 		}
-		//newBldg.Features = append(newBldg.Features, *NewFeature(n))
+
 	}
+
 	for key, value := range featuredata {
 		var feature = model.BuildingFeatureLocation{Key: key, Value: value}
 		newBldg.Features = append(newBldg.Features, feature)
@@ -181,12 +187,30 @@ func NewBuilding(bldg CampusBuilding) *model.Building {
 	return &newBldg
 }
 
+func addFeatureToList(featureKey string, featureName string, foundOnFloor string, featuredata *map[string]model.FeatureMapEntry) {
+	fd := *featuredata
+	val, ok := fd[featureKey]
+	if ok {
+		//if so, does the value of that element (slice of strings) already contain the floor number
+		//if not add it
+		if !slices.Contains(val.Floors, foundOnFloor) {
+			val.Floors = append(val.Floors, foundOnFloor)
+			fd[featureKey] = val
+		}
+	} else { //feature data does not contain an element for this key
+		var floors = make([]string, 1)
+		floors[0] = foundOnFloor
+		fme := model.FeatureMapEntry{Name: featureName, Floors: floors}
+		fd[featureKey] = fme
+	}
+}
+
 // NewBuildingList returns a list of wayfinding buildings created frmo a list of campus building objects.
-func NewBuildingList(bldgList *[]CampusBuilding) *[]model.Building {
+func NewBuildingList(bldgList *[]CampusBuilding, knownBuildings *map[string]model.AppBuildingFeature) *[]model.Building {
 	retList := make([]model.Building, len(*bldgList))
 	for i := 0; i < len(*bldgList); i++ {
 		cmpsBldg := (*bldgList)[i]
-		crntBldng := NewBuilding(cmpsBldg)
+		crntBldng := NewBuilding(cmpsBldg, knownBuildings)
 		retList[i] = *crntBldng
 	}
 	return &retList

driven/storage/adapter_buildingfeatures.go

@@ -0,0 +1,39 @@
+// Copyright 2022 Board of Trustees of the University of Illinois.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package storage
+
+import (
+	"application/core/model"
+	"time"
+
+	"github.com/rokwire/logging-library-go/v2/errors"
+	"github.com/rokwire/logging-library-go/v2/logutils"
+)
+
+// LoadAppBuildingFeatures loads all of the configured building features
+func (a *Adapter) LoadAppBuildingFeatures() ([]model.AppBuildingFeature, error) {
+
+	var data []model.AppBuildingFeature
+	//filter := bson.M{}
+	timeout := 15 * time.Second //15 seconds timeout
+	//err := a.db.legacyEvents.FindWithParams(context, filter, &data, nil, &timeout)
+	err := a.db.appbuildingfeatures.FindWithParams(a.context, nil, &data, nil, &timeout)
+	//err := a.db.appbuildingfeatures.FindWithContext(a.context, nil, &data, nil)
+	if err != nil {
+		return nil, errors.WrapErrorAction(logutils.ActionFind, model.TypeExample, filterArgs(nil), err)
+	}
+
+	return data, nil
+}

driven/storage/database.go

@@ -38,10 +38,11 @@ type database struct {
 	dbClient *mongo.Client
 	logger   *logs.Logger
 
-	globalConfigs *collectionWrapper
-	configs       *collectionWrapper
-	examples      *collectionWrapper
-	unitcalendars *collectionWrapper
+	globalConfigs       *collectionWrapper
+	configs             *collectionWrapper
+	examples            *collectionWrapper
+	unitcalendars       *collectionWrapper
+	appbuildingfeatures *collectionWrapper
 
 	legacyEvents           *collectionWrapper
 	legacyLocations        *collectionWrapper
@@ -101,6 +102,8 @@ func (d *database) start() error {
 
 	unitcalendars := &collectionWrapper{database: d, coll: db.Collection("unitcalendars")}
 
+	appbuildingfeatures := &collectionWrapper{database: d, coll: db.Collection("building_features")}
+
 	legacyLocations := &collectionWrapper{database: d, coll: db.Collection("legacy_locations")}
 	err = d.applyLegacyLocationsChecks(legacyEvents)
 	if err != nil {
@@ -128,6 +131,7 @@ func (d *database) start() error {
 	d.examples = examples
 	d.legacyEvents = legacyEvents
 	d.unitcalendars = unitcalendars
+	d.appbuildingfeatures = appbuildingfeatures
 	d.legacyLocations = legacyLocations
 	d.webtoolsBlacklistItems = webtoolsBlacklistItems
 	d.processedImages = processedImages

driven/uiucadapters/wayfindingadapter.go

@@ -28,11 +28,12 @@ import (
 
 // UIUCWayFinding is a vendor specific structure that implements the BuildingLocation interface
 type UIUCWayFinding struct {
+	KnownBuildingFeatures *map[string]model.AppBuildingFeature
 }
 
 // NewUIUCWayFinding returns a new instance of a UIUCWayFinding struct
-func NewUIUCWayFinding() *UIUCWayFinding {
-	return &UIUCWayFinding{}
+func NewUIUCWayFinding(knownfeatures *map[string]model.AppBuildingFeature) *UIUCWayFinding {
+	return &UIUCWayFinding{KnownBuildingFeatures: knownfeatures}
 }
 
 // GetEntrance returns the active entrance closest to the user's position that meets the ADA Accessibility filter requirement
@@ -76,7 +77,7 @@ func (uwf *UIUCWayFinding) GetBuildings(conf *model.EnvConfigData) (*[]model.Bui
 	if err != nil {
 		return nil, err
 	}
-	returnList := uiuc.NewBuildingList(cmpBldgs)
+	returnList := uiuc.NewBuildingList(cmpBldgs, uwf.KnownBuildingFeatures)
 	return returnList, nil
 }
 
@@ -107,7 +108,7 @@ func (uwf *UIUCWayFinding) GetBuilding(bldgID string, adaAccessibleOnly bool, la
 		bldg := model.Building{}
 		return &bldg, err
 	}
-	return uiuc.NewBuilding((*cmpBldg)[0]), nil
+	return uiuc.NewBuilding((*cmpBldg)[0], uwf.KnownBuildingFeatures), nil
 }
 
 // GetFloorPlan returns the requested floor plan