|
69 | 69 | async function get_allowed_objects() { |
70 | 70 | toggle_loading() |
71 | 71 | allowed_objects.value = {} |
72 | | - var promise_array = [] |
73 | | - for (const filename of filenames) { |
74 | | - const params = { filename, supported_feature } |
75 | | - const promise = api_fetch({ schema, params }) |
76 | | - promise_array.push(promise) |
77 | | - } |
78 | | - const responses = await Promise.all(promise_array) |
79 | | - let values = [] |
80 | | - for (const response of responses) { |
81 | | - values.push(response.data.value.allowed_objects) |
82 | | - } |
83 | | - const all_keys = [...new Set(values.flatMap((value) => Object.keys(value)))] |
84 | | - const common_keys = all_keys.filter( |
85 | | - (i) => !values.some((j) => !Object.keys(j).includes(i)), |
| 72 | + const responses = await Promise.all( |
| 73 | + filenames.map((filename) => |
| 74 | + api_fetch({ schema, params: { filename, supported_feature } }), |
| 75 | + ) |
86 | 76 | ) |
87 | | - var final_object = {} |
88 | | - for (const key of common_keys) { |
89 | | - for (const value of values) { |
90 | | - if (value[key].is_loadable == false) { |
91 | | - final_object[key] = { is_loadable: false } |
92 | | - } else { |
93 | | - final_object[key] = { is_loadable: true } |
94 | | - } |
| 77 | + const values = responses.map((r) => r.data.value.allowed_objects) |
| 78 | + const allKeys = [...new Set(values.flatMap((v) => Object.keys(v)))] |
| 79 | + const commonKeys = allKeys.filter( |
| 80 | + (key) => !values.some((obj) => !Object.prototype.hasOwnProperty.call(obj, key)), |
| 81 | + ) |
| 82 | + const finalObject = {} |
| 83 | + for (const key of commonKeys) { |
| 84 | + const loadScores = values.map((obj) => obj[key].is_loadable) |
| 85 | + const priorities = values |
| 86 | + .map((obj) => obj[key].object_priority) |
| 87 | + .filter((p) => p !== undefined && p !== null) |
| 88 | + finalObject[key] = { is_loadable: Math.min(...loadScores) } |
| 89 | + if (priorities.length) { |
| 90 | + finalObject[key].object_priority = Math.max(...priorities) |
95 | 91 | } |
96 | 92 | } |
97 | | - if (Object.keys(final_object).length > 0) { |
98 | | - const max_loadability_score = Math.max( |
99 | | - ...Object.values(final_object).map(obj => obj.is_loadable ? 1 : 0) |
| 93 | + allowed_objects.value = finalObject |
| 94 | + let alreadySelected = false |
| 95 | + const objectKeys = Object.keys(finalObject) |
| 96 | + if (objectKeys.length) { |
| 97 | + const highestLoadScore = Math.max( |
| 98 | + ...objectKeys.map((key) => finalObject[key].is_loadable) |
100 | 99 | ) |
101 | | - |
102 | | - const best_objects = Object.fromEntries( |
103 | | - Object.entries(final_object).filter( |
104 | | - ([object_name, object_info]) => (object_info.is_loadable ? 1 : 0) === max_loadability_score |
| 100 | + if (highestLoadScore > 0) { |
| 101 | + const bestScoreObjects = objectKeys.filter( |
| 102 | + (key) => finalObject[key].is_loadable === highestLoadScore |
105 | 103 | ) |
106 | | - ) |
107 | | - |
108 | | - if (Object.keys(best_objects).length > 1) { |
109 | | - const priorities = {} |
110 | | - for (const object_name of Object.keys(best_objects)) { |
111 | | - const priority_response = await api_fetch({ |
112 | | - schema: schemas.opengeodeweb_back.object_priority, |
113 | | - params: { object_name, filename: filenames[0] } |
114 | | - }) |
115 | | - priorities[object_name] = priority_response.data.value.priority |
| 104 | + if (bestScoreObjects.length === 1) { |
| 105 | + set_geode_object(bestScoreObjects[0]) |
| 106 | + alreadySelected = true |
| 107 | + } else { |
| 108 | + const highestPriority = Math.max( |
| 109 | + ...bestScoreObjects.map( |
| 110 | + (key) => finalObject[key].object_priority ?? -Infinity |
| 111 | + ) |
| 112 | + ) |
| 113 | + const bestPriorityObjects = bestScoreObjects.filter( |
| 114 | + (key) => finalObject[key].object_priority === highestPriority |
| 115 | + ) |
| 116 | + if (highestPriority !== -Infinity && bestPriorityObjects.length === 1) { |
| 117 | + set_geode_object(bestPriorityObjects[0]) |
| 118 | + alreadySelected = true |
| 119 | + } |
116 | 120 | } |
117 | | - |
118 | | - const best_object_name = Object.keys(best_objects).reduce((a, b) => |
119 | | - priorities[a] > priorities[b] ? a : b |
120 | | - ) |
121 | | - |
122 | | - allowed_objects.value = { [best_object_name]: final_object[best_object_name] } |
123 | | - } else { |
124 | | - allowed_objects.value = best_objects |
125 | 121 | } |
126 | | - } else { |
127 | | - allowed_objects.value = final_object |
128 | 122 | } |
129 | | - if (Object.keys(allowed_objects.value).length == 1) { |
130 | | - set_geode_object(Object.keys(allowed_objects.value)[0]) |
| 123 | + if (!alreadySelected && objectKeys.length === 1) { |
| 124 | + set_geode_object(objectKeys[0]) |
131 | 125 | } |
132 | 126 | toggle_loading() |
133 | 127 | } |
|
0 commit comments