mattermost-mobile-upstream/detox/e2e/support/server_api/properties.ts
Andre Vasconcelos e18fc6921e
MM-68208 Implementing global and channel-level banners on mobile (#9752)
* Expo-Router partial migration

* Full migration to ExpoRouter

* i18n

* add tests

* library hardware-keyboard android new arch support fix

* library rnshare android new arch support fix

* library rnutils android new arch support fix

* library secure-pdf-viewer add new arch support

* Enable new arch on iOS and Android

* update emm and network client with new-arch

* update intune to use new-arch

* performance improvements

* fix tests

* fixes post input on new-arch

* Merge branch 'main' into expo-router

* fix android emoji picker

* align package-lock.json

* i18n

* feedback review

* feedback review

* android 16kb patch

* Refactored emoji picker keyboard using a state machine

* set android launch_screen in drawables instead of layout

* no conditional hooks

* remove duplicate call in test

* address feedback

* fix tests and address more feedback

* small corrections

* small corrections

* small corrections

* fix draft test

* fix draft test 2

* remove navigateToScreen in draff test

* fix nit in draft test

* remove doc file

* remove doc

* run tests in parallel

* Feedback review

* fix snapshots

* improve test coverage

* fix i18n

* upgrade to React Native 0.83.9, Expo 55, React 19, and New Architecture

Bumps core dependencies to their latest versions:
- React Native 0.77.3 → 0.83.9 (New Architecture enabled)
- React 18.3.1 → 19.2.5
- Expo SDK 52 → 55
- TypeScript 5.8.3 → 6.0.3
- Node.js 22.16.0 → 24.15.0
- react-native-reanimated 3.17.3 → 4.3.0
- Various other dependency upgrades

Migrates iOS AppDelegate from Objective-C to Swift, updates Android
build tooling and Gradle wrapper, refreshes all patches and font
assets, and adapts app code, tests, and CI workflows throughout for
API changes introduced by these upgrades.

* remove unecessary dismissKeyboard in notifications

* feedback review

* update intune to use new-arch

* update @mattermost deps

* missing i18n string

* additional fixes

* update fastlane

* Re-implementing global classification banners on top of rn83

* Refactoring to de-couple the classification banner from the layout

* Implementing per-channel banners on mobile

* Removing custom header in favor of common component

* Making fixes for coderabbit

* Improving padding calculation

* Converting global classification banner to use portals

* Removing dead code, adding deletion check

* Addressing dryrun securit concerns

* Removing call for template field, improving consistency

* MM-68208 Storing system property values in WatermelonDB (#9781)

* Added persistence layer to system properties

* Making debounce behavior more consistent

* Cleaning up debounce logic from store persistence

* Addressing PR feedback

* Removing ephemeral store usage and employing observables

- Changing name of group to access_control

* Updating unit tests

* Refactoring to improve code consistency

- Removing any patterns introduced that weren't already established in the repo
- Removing hooks with database reads in favor of withObservables and withDatabase pattern
- Simplifying _layout.tsx by removing inset modification, now handled in the Container HoC component
- Moved some repeated hook logic into its own utils file

* Refactoring to use propertyfield and propertyvalue tables instead of system

- Simplified remote actions to purely perform API call, and call a local action to sync values
- Using local action layer to perform syncing and removal operations of property fields and values
- Observables now pre-filter for active fields / values via querying for delete_at=0

* Improving consistency of local actions

- Added unit tests for syncPropertyFieldsByGroupId, syncPropertyValuesByTargetId, clearClassificationData

* Replacing local actions with operator handlers

* Removing needless mocks from unit tests

* Consolidating operator handlers

- Leaving 1 handler for fields and 1 for values, each of them evaluating whether to delete or upsert values received in the function call

* MM-68208 Making changes based on feedback

- Removing !visible guard in global classification container
- Increasing clarity of comment for clearing of stale fields
- Updating log messages to be more clear

* Batching database operations together for fields and values

* Consolidating API call for fetching classification data

- Preparation for caching mechanism

* Updating field names to the unified classification

* Updating E2E test values to match current field names

---------

Co-authored-by: Elias Nahum <nahumhbl@gmail.com>
Co-authored-by: Mattermost Build <build@mattermost.com>
2026-07-08 12:47:01 +03:00

248 lines
8.3 KiB
TypeScript

// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
import client from './client';
import {getResponseFromError} from './common';
const GROUP_NAME = 'access_control';
const OBJECT_TYPE = 'template';
const TARGET_TYPE = 'system';
const FIELD_NAME = 'classification';
const LINKED_FIELD_NAME = 'classification';
const LINKED_OBJECT_TYPE = 'system';
const DISPLAY_BANNER_TOP = 'display_banner_top';
type PropertyFieldOption = {
id: string;
name: string;
color: string;
rank?: number;
};
/**
* Get all property fields for a group/objectType.
*/
export const apiGetPropertyFields = async (baseUrl: string, groupName: string, objectType: string, targetType: string, targetId?: string) => {
try {
let url = `${baseUrl}/api/v4/properties/groups/${groupName}/${objectType}/fields?target_type=${targetType}`;
if (targetId !== undefined) {
url += `&target_id=${encodeURIComponent(targetId)}`;
}
const response = await client.get(url);
return {fields: response.data};
} catch (err) {
return getResponseFromError(err);
}
};
/**
* Create a property field.
*/
export const apiCreatePropertyField = async (baseUrl: string, groupName: string, objectType: string, field: Record<string, unknown>) => {
try {
const response = await client.post(
`${baseUrl}/api/v4/properties/groups/${groupName}/${objectType}/fields`,
field,
);
return {field: response.data};
} catch (err) {
return getResponseFromError(err);
}
};
/**
* Delete a property field.
*/
export const apiDeletePropertyField = async (baseUrl: string, groupName: string, objectType: string, fieldId: string) => {
try {
await client.delete(`${baseUrl}/api/v4/properties/groups/${groupName}/${objectType}/fields/${fieldId}`);
return {};
} catch (err) {
return getResponseFromError(err);
}
};
/**
* Get property values for a target.
*/
export const apiGetPropertyValues = async (baseUrl: string, groupName: string, objectType: string, targetId: string) => {
try {
const response = await client.get(
`${baseUrl}/api/v4/properties/groups/${groupName}/${objectType}/values/${targetId}`,
);
return {values: response.data};
} catch (err) {
return getResponseFromError(err);
}
};
/**
* Upsert property values for a target.
*/
export const apiPatchPropertyValues = async (baseUrl: string, groupName: string, objectType: string, targetId: string, values: Array<{field_id: string; value: string}>) => {
try {
const response = await client.patch(
`${baseUrl}/api/v4/properties/groups/${groupName}/${objectType}/values/${targetId}`,
values,
);
return {values: response.data};
} catch (err) {
return getResponseFromError(err);
}
};
/**
* Get system-scoped property values.
*/
export const apiGetSystemPropertyValues = async (baseUrl: string, groupName: string) => {
try {
const response = await client.get(
`${baseUrl}/api/v4/properties/groups/${groupName}/system/values`,
);
return {values: response.data};
} catch (err) {
return getResponseFromError(err);
}
};
/**
* Upsert system-scoped property values.
*/
export const apiPatchSystemPropertyValues = async (baseUrl: string, groupName: string, values: Array<{field_id: string; value: string}>) => {
try {
const response = await client.patch(
`${baseUrl}/api/v4/properties/groups/${groupName}/system/values`,
values,
);
return {values: response.data};
} catch (err) {
return getResponseFromError(err);
}
};
/**
* Setup a complete classification system for E2E testing:
* 1. Create a template property field with classification levels
* 2. Create a linked system classification field with banner actions
* 3. Set a system property value for the classification level
*
* Levels are identified by their `id` field. The `levelId` option selects which
* level the global banner should display, matching the approach used in the
* webapp E2E tests (keyed by option ID, not name).
*
* @returns Object containing the created field IDs and option IDs
*/
export const apiSetupClassificationWithBanner = async (
baseUrl: string,
options?: {
levels?: PropertyFieldOption[];
levelId?: string;
},
) => {
const levels = options?.levels ?? [
{id: 'lvl-top-secret', name: 'TOP SECRET', color: '#FCE83A', rank: 1},
{id: 'lvl-secret', name: 'SECRET', color: '#FF0000', rank: 2},
{id: 'lvl-unclassified', name: 'UNCLASSIFIED', color: '#00FF00', rank: 3},
];
const levelId = options?.levelId ?? 'lvl-top-secret';
await apiCleanupClassification(baseUrl);
const templateResult = await apiCreatePropertyField(baseUrl, GROUP_NAME, OBJECT_TYPE, {
name: FIELD_NAME,
type: 'select',
target_type: TARGET_TYPE,
target_id: '',
attrs: {
options: levels.map((l) => ({id: l.id, name: l.name, color: l.color, rank: l.rank})),
managed: 'admin',
},
permission_field: 'sysadmin',
permission_values: 'sysadmin',
permission_options: 'sysadmin',
});
const templateResult_ = templateResult as {field: any};
if (!templateResult_.field) {
throw new Error('Failed to create template classification field');
}
const templateField = templateResult_.field;
const templateOptions = templateField.attrs?.options ?? [];
const selectedOption = templateOptions.find((o: PropertyFieldOption) => o.id === levelId);
if (!selectedOption) {
const available = templateOptions.map((o: PropertyFieldOption) => `${o.name} (${o.id})`).join(', ');
throw new Error(`Classification level ID "${levelId}" not found in created options. Available: [${available}]`);
}
const linkedResult = await apiCreatePropertyField(baseUrl, GROUP_NAME, LINKED_OBJECT_TYPE, {
name: LINKED_FIELD_NAME,
type: 'select',
target_type: TARGET_TYPE,
target_id: '',
linked_field_id: templateField.id,
attrs: {
actions: [DISPLAY_BANNER_TOP],
},
});
const linkedResult_ = linkedResult as {field: any};
if (!linkedResult_.field) {
throw new Error('Failed to create linked system classification field');
}
const linkedField = linkedResult_.field;
const patchResult = await apiPatchSystemPropertyValues(baseUrl, GROUP_NAME, [
{field_id: linkedField.id, value: selectedOption.id},
]);
if ('error' in patchResult) {
throw new Error(`Failed to set system property value for field_id=${linkedField.id}, value=${selectedOption.id}: ${JSON.stringify(patchResult.error)}`);
}
return {
templateFieldId: templateField.id,
linkedFieldId: linkedField.id,
selectedOptionId: selectedOption.id,
};
};
/**
* Clean up classification property fields and values.
*/
export const apiCleanupClassification = async (baseUrl: string) => {
const linkedFieldsResult = await apiGetPropertyFields(baseUrl, GROUP_NAME, LINKED_OBJECT_TYPE, TARGET_TYPE) as {fields?: any[]};
if (linkedFieldsResult.fields) {
for (const field of linkedFieldsResult.fields) {
if (field.name === LINKED_FIELD_NAME && field.delete_at === 0) {
// eslint-disable-next-line no-await-in-loop
await apiDeletePropertyField(baseUrl, GROUP_NAME, LINKED_OBJECT_TYPE, field.id);
}
}
}
const templateFieldsResult = await apiGetPropertyFields(baseUrl, GROUP_NAME, OBJECT_TYPE, TARGET_TYPE) as {fields?: any[]};
if (templateFieldsResult.fields) {
for (const field of templateFieldsResult.fields) {
if (field.name === FIELD_NAME && field.delete_at === 0) {
// eslint-disable-next-line no-await-in-loop
await apiDeletePropertyField(baseUrl, GROUP_NAME, OBJECT_TYPE, field.id);
}
}
}
};
export const Properties = {
apiGetPropertyFields,
apiCreatePropertyField,
apiDeletePropertyField,
apiGetPropertyValues,
apiPatchPropertyValues,
apiGetSystemPropertyValues,
apiPatchSystemPropertyValues,
apiSetupClassificationWithBanner,
apiCleanupClassification,
};
export default Properties;