0c4a42a06a
* Remove the t function and all wrong uses of preventDoubleTap * Fix existing typo * Fix tests * Address comments * Fix test
730 lines
24 KiB
TypeScript
730 lines
24 KiB
TypeScript
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
import moment from 'moment-timezone';
|
|
import {defineMessages, type IntlShape} from 'react-intl';
|
|
import {Alert} from 'react-native';
|
|
|
|
import {General, Permissions, Preferences} from '@constants';
|
|
import {Ringtone} from '@constants/calls';
|
|
import {CustomStatusDurationEnum} from '@constants/custom_status';
|
|
import {DEFAULT_LOCALE, getLocalizedMessage} from '@i18n';
|
|
import {safeParseJSON, toTitleCase} from '@utils/helpers';
|
|
import {logError} from '@utils/log';
|
|
|
|
import type {CustomProfileFieldModel, CustomProfileAttributeModel} from '@database/models/server';
|
|
import type {CustomAttribute, CustomAttributeSet} from '@typings/api/custom_profile_attributes';
|
|
import type UserModel from '@typings/database/models/servers/user';
|
|
|
|
const displayUsernameMessages = defineMessages({
|
|
someone: {
|
|
id: 'channel_loader.someone',
|
|
defaultMessage: 'Someone',
|
|
},
|
|
});
|
|
|
|
export function displayUsername(user?: UserProfile | UserModel | null, locale?: string, teammateDisplayNameSetting?: string, useFallbackUsername = true) {
|
|
let name = useFallbackUsername ? getLocalizedMessage(locale || DEFAULT_LOCALE, displayUsernameMessages.someone.id, displayUsernameMessages.someone.defaultMessage) : '';
|
|
|
|
if (user) {
|
|
if (teammateDisplayNameSetting === Preferences.DISPLAY_PREFER_NICKNAME) {
|
|
name = user.nickname || getFullName(user);
|
|
} else if (teammateDisplayNameSetting === Preferences.DISPLAY_PREFER_FULL_NAME) {
|
|
name = getFullName(user);
|
|
} else {
|
|
name = user.username;
|
|
}
|
|
|
|
if (!name || name.trim().length === 0) {
|
|
name = user.username;
|
|
}
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
export function displayGroupMessageName(users: Array<UserProfile | UserModel>, locale?: string, teammateDisplayNameSetting?: string, excludeUserId?: string) {
|
|
const names: string[] = [];
|
|
const sortUsernames = (a: string, b: string) => {
|
|
return a.localeCompare(b, locale || DEFAULT_LOCALE, {numeric: true});
|
|
};
|
|
|
|
users.forEach((u) => {
|
|
if (u.id !== excludeUserId) {
|
|
names.push(displayUsername(u, locale, teammateDisplayNameSetting, false) || u.username);
|
|
}
|
|
});
|
|
|
|
return names.sort(sortUsernames).join(', ').trim();
|
|
}
|
|
|
|
export function getFullName(user: UserProfile | UserModel): string {
|
|
let firstName: string;
|
|
let lastName: string;
|
|
|
|
if ('lastName' in user) {
|
|
firstName = user.firstName;
|
|
lastName = user.lastName;
|
|
} else {
|
|
firstName = user.first_name;
|
|
lastName = user.last_name;
|
|
}
|
|
|
|
if (firstName && lastName) {
|
|
return `${firstName} ${lastName}`;
|
|
} else if (firstName) {
|
|
return firstName;
|
|
} else if (lastName) {
|
|
return lastName;
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
export function getUserIdFromChannelName(knownUserId: string, channelName: string): string {
|
|
const ids = channelName.split('__');
|
|
if (ids[0] === knownUserId) {
|
|
return ids[1];
|
|
}
|
|
return ids[0];
|
|
}
|
|
|
|
export function isRoleInRoles(roles: string, role: string): boolean {
|
|
const rolesArray = roles.split(' ');
|
|
return rolesArray.includes(role);
|
|
}
|
|
|
|
export function isGuest(roles: string): boolean {
|
|
return isRoleInRoles(roles, Permissions.SYSTEM_GUEST_ROLE);
|
|
}
|
|
|
|
export function isSystemAdmin(roles: string): boolean {
|
|
return isRoleInRoles(roles, Permissions.SYSTEM_ADMIN_ROLE);
|
|
}
|
|
|
|
export function isChannelAdmin(roles: string): boolean {
|
|
return isRoleInRoles(roles, Permissions.CHANNEL_ADMIN_ROLE);
|
|
}
|
|
|
|
export const getUsersByUsername = (users: UserModel[]) => {
|
|
const usersByUsername: Dictionary<UserModel> = {};
|
|
|
|
for (const user of users) {
|
|
usersByUsername[user.username] = user;
|
|
}
|
|
|
|
return usersByUsername;
|
|
};
|
|
|
|
export const getUserTimezoneProps = (currentUser?: UserModel) => {
|
|
if (currentUser?.timezone) {
|
|
return {
|
|
...currentUser?.timezone,
|
|
useAutomaticTimezone: currentUser?.timezone?.useAutomaticTimezone === 'true',
|
|
};
|
|
}
|
|
|
|
return {
|
|
useAutomaticTimezone: true,
|
|
automaticTimezone: '',
|
|
manualTimezone: '',
|
|
};
|
|
};
|
|
|
|
export const getUserTimezone = (user?: UserModel | UserProfile) => {
|
|
return getTimezone(user?.timezone);
|
|
};
|
|
|
|
export const getTimezone = (timezone?: UserTimezone | null) => {
|
|
if (!timezone) {
|
|
return '';
|
|
}
|
|
|
|
const {useAutomaticTimezone} = timezone;
|
|
let useAutomatic = useAutomaticTimezone;
|
|
if (typeof useAutomaticTimezone === 'string') {
|
|
useAutomatic = useAutomaticTimezone === 'true';
|
|
}
|
|
|
|
if (useAutomatic) {
|
|
return timezone.automaticTimezone;
|
|
}
|
|
|
|
return timezone.manualTimezone;
|
|
};
|
|
|
|
export const getTimezoneRegion = (timezone: string): string => {
|
|
if (timezone) {
|
|
const split = timezone.split('/');
|
|
if (split.length > 1) {
|
|
return split.pop()!.replace(/_/g, ' ');
|
|
}
|
|
}
|
|
|
|
return timezone;
|
|
};
|
|
|
|
export const getUserCustomStatus = (user?: UserModel | UserProfile): UserCustomStatus | undefined => {
|
|
try {
|
|
if (typeof user?.props?.customStatus === 'string') {
|
|
return JSON.parse(user.props.customStatus);
|
|
}
|
|
|
|
return user?.props?.customStatus;
|
|
} catch {
|
|
return undefined;
|
|
}
|
|
};
|
|
|
|
export function isCustomStatusExpired(user?: UserModel | UserProfile) {
|
|
if (!user) {
|
|
return true;
|
|
}
|
|
|
|
const customStatus = getUserCustomStatus(user);
|
|
|
|
if (!customStatus) {
|
|
return true;
|
|
}
|
|
|
|
if (customStatus.duration === CustomStatusDurationEnum.DONT_CLEAR || !customStatus.duration) {
|
|
return false;
|
|
}
|
|
|
|
const expiryTime = moment(customStatus.expires_at);
|
|
const timezone = getUserTimezone(user);
|
|
const currentTime = timezone ? moment.tz(timezone) : moment();
|
|
return currentTime.isSameOrAfter(expiryTime);
|
|
}
|
|
|
|
export function confirmOutOfOfficeDisabled(intl: IntlShape, status: string, updateStatus: (status: string) => void) {
|
|
let translatedStatus;
|
|
switch (status) {
|
|
case General.DND:
|
|
translatedStatus = intl.formatMessage({
|
|
id: 'mobile.set_status.dnd',
|
|
defaultMessage: 'Do Not Disturb',
|
|
});
|
|
break;
|
|
case General.AWAY:
|
|
translatedStatus = intl.formatMessage({
|
|
id: 'mobile.set_status.away',
|
|
defaultMessage: 'Away',
|
|
});
|
|
break;
|
|
case General.OFFLINE:
|
|
translatedStatus = intl.formatMessage({
|
|
id: 'mobile.set_status.offline',
|
|
defaultMessage: 'Offline',
|
|
});
|
|
break;
|
|
case General.ONLINE:
|
|
translatedStatus = intl.formatMessage({
|
|
id: 'mobile.set_status.online',
|
|
defaultMessage: 'Online',
|
|
});
|
|
break;
|
|
default:
|
|
translatedStatus = toTitleCase(status);
|
|
break;
|
|
}
|
|
|
|
Alert.alert(
|
|
intl.formatMessage({
|
|
id: 'mobile.reset_status.title_ooo',
|
|
defaultMessage: 'Disable "Out Of Office"?',
|
|
}),
|
|
intl.formatMessage({
|
|
id: 'modal.manual_status.auto_responder.message_',
|
|
defaultMessage: 'Would you like to switch your status to "{status}" and disable Automatic Replies?',
|
|
}, {status: translatedStatus}),
|
|
[{
|
|
text: intl.formatMessage({id: 'mobile.reset_status.alert_cancel', defaultMessage: 'Cancel'}),
|
|
style: 'cancel',
|
|
}, {
|
|
text: intl.formatMessage({id: 'mobile.reset_status.alert_ok', defaultMessage: 'OK'}),
|
|
onPress: () => updateStatus(status),
|
|
}],
|
|
);
|
|
}
|
|
|
|
export function isBot(user: UserProfile | UserModel): boolean {
|
|
return 'isBot' in user ? Boolean(user.isBot) : Boolean(user.is_bot);
|
|
}
|
|
|
|
export function isShared(user: UserProfile | UserModel): boolean {
|
|
return ('remoteId' in user) ? Boolean(user.remoteId) : Boolean(user.remote_id);
|
|
}
|
|
|
|
export function isDeactivated(user: UserProfile | UserModel): boolean {
|
|
return Boolean('deleteAt' in user ? user.deleteAt : user.delete_at);
|
|
}
|
|
|
|
export function removeUserFromList(userId: string, originalList: UserProfile[]): UserProfile[] {
|
|
const list = [...originalList];
|
|
for (let i = list.length - 1; i >= 0; i--) {
|
|
if (list[i].id === userId) {
|
|
list.splice(i, 1);
|
|
return list;
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
// Splits the term by a splitStr and composes a list of the parts of
|
|
// the split concatenated with the rest, forming a set of suggesitons
|
|
// matchable with startsWith
|
|
//
|
|
// E.g.: for "one.two.three" by "." it would yield
|
|
// ["one.two.three", ".two.three", "two.three", ".three", "three"]
|
|
export function getSuggestionsSplitBy(term: string, splitStr: string): string[] {
|
|
const splitTerm = term.split(splitStr);
|
|
const initialSuggestions = splitTerm.map((st, i) => splitTerm.slice(i).join(splitStr));
|
|
let suggestions: string[] = [];
|
|
|
|
if (splitStr === ' ') {
|
|
suggestions = initialSuggestions;
|
|
} else {
|
|
suggestions = initialSuggestions.reduce<string[]>((acc, val) => {
|
|
if (acc.length === 0) {
|
|
acc.push(val);
|
|
} else {
|
|
acc.push(splitStr + val, val);
|
|
}
|
|
return acc;
|
|
}, []);
|
|
}
|
|
return suggestions;
|
|
}
|
|
|
|
export function getSuggestionsSplitByMultiple(term: string, splitStrs: string[]): string[] {
|
|
const suggestions = splitStrs.reduce((acc, val) => {
|
|
getSuggestionsSplitBy(term, val).forEach((suggestion) => acc.add(suggestion));
|
|
return acc;
|
|
}, new Set<string>());
|
|
|
|
return [...suggestions];
|
|
}
|
|
|
|
export function filterProfilesMatchingTerm(users: UserProfile[], term: string): UserProfile[] {
|
|
const lowercasedTerm = term.toLowerCase();
|
|
let trimmedTerm = lowercasedTerm;
|
|
if (trimmedTerm.startsWith('@')) {
|
|
trimmedTerm = trimmedTerm.substring(1);
|
|
}
|
|
|
|
return users.filter((user: UserProfile) => {
|
|
if (!user) {
|
|
return false;
|
|
}
|
|
|
|
const profileSuggestions: string[] = [];
|
|
const usernameSuggestions = getSuggestionsSplitByMultiple((user.username || '').toLowerCase(), General.AUTOCOMPLETE_SPLIT_CHARACTERS);
|
|
profileSuggestions.push(...usernameSuggestions);
|
|
const first = (user.first_name || '').toLowerCase();
|
|
const last = (user.last_name || '').toLowerCase();
|
|
const full = first + ' ' + last;
|
|
profileSuggestions.push(first, last, full);
|
|
profileSuggestions.push((user.nickname || '').toLowerCase());
|
|
const email = (user.email || '').toLowerCase();
|
|
profileSuggestions.push(email);
|
|
profileSuggestions.push((user.nickname || '').toLowerCase());
|
|
|
|
const split = email.split('@');
|
|
if (split.length > 1) {
|
|
profileSuggestions.push(split[1]);
|
|
}
|
|
|
|
return profileSuggestions.
|
|
filter((suggestion) => suggestion !== '').
|
|
some((suggestion) => suggestion.includes(trimmedTerm));
|
|
});
|
|
}
|
|
|
|
export function getNotificationProps(user?: UserModel) {
|
|
if (user && user.notifyProps) {
|
|
return user.notifyProps;
|
|
}
|
|
|
|
const props: UserNotifyProps = {
|
|
channel: 'true',
|
|
comments: 'any',
|
|
desktop: 'all',
|
|
desktop_sound: 'true',
|
|
email: 'true',
|
|
first_name: (!user || !user.firstName) ? 'false' : 'true',
|
|
mark_unread: 'all',
|
|
mention_keys: user?.username ? `${user.username},@${user.username}` : '',
|
|
highlight_keys: '',
|
|
push: 'mention',
|
|
push_status: 'online',
|
|
push_threads: 'all',
|
|
email_threads: 'all',
|
|
calls_desktop_sound: 'true',
|
|
calls_notification_sound: Ringtone.Calm,
|
|
calls_mobile_sound: '',
|
|
calls_mobile_notification_sound: '',
|
|
};
|
|
|
|
return props;
|
|
}
|
|
|
|
export function getEmailInterval(enableEmailNotification: boolean, enableEmailBatching: boolean, emailIntervalPreference: number): number {
|
|
const {
|
|
INTERVAL_NEVER,
|
|
INTERVAL_IMMEDIATE,
|
|
INTERVAL_FIFTEEN_MINUTES,
|
|
INTERVAL_HOUR,
|
|
} = Preferences;
|
|
|
|
const validValuesWithEmailBatching = [INTERVAL_IMMEDIATE, INTERVAL_NEVER, INTERVAL_FIFTEEN_MINUTES, INTERVAL_HOUR];
|
|
const validValuesWithoutEmailBatching = [INTERVAL_IMMEDIATE, INTERVAL_NEVER];
|
|
|
|
if (!enableEmailNotification) {
|
|
return INTERVAL_NEVER;
|
|
} else if (enableEmailBatching && validValuesWithEmailBatching.indexOf(emailIntervalPreference) === -1) {
|
|
// When email batching is enabled, the default interval is 15 minutes
|
|
return INTERVAL_FIFTEEN_MINUTES;
|
|
} else if (!enableEmailBatching && validValuesWithoutEmailBatching.indexOf(emailIntervalPreference) === -1) {
|
|
// When email batching is not enabled, the default interval is immediately
|
|
return INTERVAL_IMMEDIATE;
|
|
} else if (enableEmailNotification && emailIntervalPreference === INTERVAL_NEVER) {
|
|
// When email notification is enabled, the default interval is immediately
|
|
return INTERVAL_IMMEDIATE;
|
|
}
|
|
|
|
return emailIntervalPreference;
|
|
}
|
|
|
|
export const getEmailIntervalTexts = (interval: string) => {
|
|
const intervalTexts: Record<string, any> = {
|
|
[Preferences.INTERVAL_FIFTEEN_MINUTES]: {id: 'notification_settings.email.fifteenMinutes', defaultMessage: 'Every 15 minutes'},
|
|
[Preferences.INTERVAL_HOUR]: {id: 'notification_settings.email.everyHour', defaultMessage: 'Every hour'},
|
|
[Preferences.INTERVAL_IMMEDIATE]: {id: 'notification_settings.email.immediately', defaultMessage: 'Immediately'},
|
|
[Preferences.INTERVAL_NEVER]: {id: 'notification_settings.email.never', defaultMessage: 'Never'},
|
|
};
|
|
return intervalTexts[interval];
|
|
};
|
|
|
|
export const getLastPictureUpdate = (user: UserModel | UserProfile) => {
|
|
if ('isBot' in user) {
|
|
return user.isBot ? user.props?.bot_last_icon_update : user.lastPictureUpdate || 0;
|
|
}
|
|
|
|
return user.is_bot ? user.bot_last_icon_update : user.last_picture_update || 0;
|
|
};
|
|
|
|
/**
|
|
* Sorts custom profile attributes by their sort_order property, falling back to name comparison.
|
|
* Attributes with undefined sort_order are placed last.
|
|
* @param a First CustomAttribute to compare
|
|
* @param b Second CustomAttribute to compare
|
|
* @returns Negative if a comes first, positive if b comes first, 0 if equal
|
|
*/
|
|
export const sortCustomProfileAttributes = (a: CustomAttribute, b: CustomAttribute): number => {
|
|
const orderA = a.sort_order ?? Number.MAX_SAFE_INTEGER;
|
|
const orderB = b.sort_order ?? Number.MAX_SAFE_INTEGER;
|
|
return orderA === orderB ? a.name.localeCompare(b.name) : orderA - orderB;
|
|
};
|
|
|
|
/**
|
|
* Converts an array of custom profile attributes to a map of attributes by their id.
|
|
* @param attributesToConvert - The array of custom profile attributes to convert
|
|
* @returns A map of attributes by their id
|
|
*/
|
|
export const convertToAttributesMap = (attributesToConvert: CustomAttributeSet | CustomAttribute[]): CustomAttributeSet => {
|
|
if (!Array.isArray(attributesToConvert)) {
|
|
return attributesToConvert as CustomAttributeSet;
|
|
}
|
|
const attributesMap: CustomAttributeSet = {};
|
|
attributesToConvert.forEach((attr) => {
|
|
attributesMap[attr.id] = attr;
|
|
});
|
|
return attributesMap;
|
|
};
|
|
|
|
export const getDisplayType = (field: CustomProfileFieldModel): string => {
|
|
if (field.type === 'text' && field.attrs?.value_type !== undefined && field.attrs.value_type !== '') {
|
|
return field.attrs.value_type;
|
|
}
|
|
return field.type;
|
|
};
|
|
|
|
/**
|
|
* Get the options from a select or multiselect field as a map of option IDs to option names
|
|
* @param field - The custom profile field
|
|
* @returns A record where keys are option IDs and values are option names
|
|
*/
|
|
export const getFieldOptions = (field: CustomProfileFieldModel): Record<string, string> => {
|
|
if (!field.attrs || (field.type !== 'select' && field.type !== 'multiselect')) {
|
|
return {};
|
|
}
|
|
|
|
const options = field.attrs.options as Array<{id: string; name: string}> | undefined;
|
|
if (!options || !Array.isArray(options)) {
|
|
return {};
|
|
}
|
|
|
|
const optionsMap: Record<string, string> = {};
|
|
options.forEach((option) => {
|
|
if (option.id && option.name) {
|
|
optionsMap[option.id] = option.name;
|
|
}
|
|
});
|
|
|
|
return optionsMap;
|
|
};
|
|
|
|
/**
|
|
* Convert option IDs to display values for select/multiselect fields
|
|
* @param value - The stored value (option ID or comma-separated IDs)
|
|
* @param fieldType - The field type ('select' or 'multiselect')
|
|
* @param optionsMap - Map of option IDs to option names
|
|
* @returns The display value with option names
|
|
*/
|
|
const convertOptionsToDisplayValue = (value: string, fieldType: string, optionsMap: Record<string, string>): string => {
|
|
if (!value || !optionsMap) {
|
|
return value;
|
|
}
|
|
|
|
if (fieldType === 'select') {
|
|
// Single select: just return the option name for the ID
|
|
return optionsMap[value] || value;
|
|
}
|
|
|
|
if (fieldType === 'multiselect') {
|
|
// Multi-select: handle comma-separated IDs or JSON array
|
|
let optionIds: string[] = [];
|
|
|
|
// Try parsing as JSON array first
|
|
try {
|
|
const parsed = JSON.parse(value);
|
|
if (Array.isArray(parsed)) {
|
|
optionIds = parsed;
|
|
} else {
|
|
// Fallback to comma-separated string
|
|
optionIds = value.split(',').map((id) => id.trim());
|
|
}
|
|
} catch {
|
|
// Fallback to comma-separated string
|
|
optionIds = value.split(',').map((id) => id.trim());
|
|
}
|
|
|
|
// Convert IDs to names and filter out empty values
|
|
const optionNames = optionIds.
|
|
map((id) => optionsMap[id] || id).
|
|
filter((name) => name.trim() !== '');
|
|
|
|
return optionNames.join(', ');
|
|
}
|
|
|
|
return value;
|
|
};
|
|
|
|
/**
|
|
* Convert custom profile attributes to the UI-ready CustomAttribute format
|
|
* @param attributes - Array of custom profile attribute models
|
|
* @param fields - Array of custom profile field models
|
|
* @param sortFn - Optional sort function
|
|
* @returns Array of formatted CustomAttribute objects
|
|
*/
|
|
export const convertProfileAttributesToCustomAttributes = (
|
|
attributes: CustomProfileAttributeModel[] | null | undefined,
|
|
fields: CustomProfileFieldModel[] | null | undefined,
|
|
sortFn?: (a: CustomAttribute, b: CustomAttribute) => number,
|
|
useDisplayType: boolean = false,
|
|
): CustomAttribute[] => {
|
|
if (!attributes?.length) {
|
|
return [];
|
|
}
|
|
|
|
const fieldsMap = new Map();
|
|
const fieldOptionsMap = new Map<string, Record<string, string>>();
|
|
fields?.forEach((field) => {
|
|
const customType = useDisplayType ? getDisplayType(field) : field.type;
|
|
fieldsMap.set(field.id, {
|
|
name: field.name,
|
|
type: customType,
|
|
sort_order: field.attrs?.sort_order ?? Number.MAX_SAFE_INTEGER,
|
|
originalField: field,
|
|
});
|
|
|
|
// Store options map for select/multiselect fields
|
|
if (field.type === 'select' || field.type === 'multiselect') {
|
|
fieldOptionsMap.set(field.id, getFieldOptions(field));
|
|
}
|
|
});
|
|
|
|
const customAttrs = attributes.map((attr) => {
|
|
const field = fieldsMap.get(attr.fieldId);
|
|
let displayValue = attr.value;
|
|
|
|
// Convert option IDs to names for select/multiselect fields
|
|
if (field && (field.type === 'select' || field.type === 'multiselect')) {
|
|
const optionsMap = fieldOptionsMap.get(attr.fieldId);
|
|
|
|
if (optionsMap && Object.keys(optionsMap).length > 0) {
|
|
displayValue = convertOptionsToDisplayValue(attr.value, field.type, optionsMap);
|
|
}
|
|
}
|
|
|
|
return ({
|
|
id: attr.fieldId,
|
|
name: field?.name || attr.fieldId,
|
|
type: field?.type || 'text',
|
|
value: displayValue,
|
|
sort_order: field?.sort_order ?? Number.MAX_SAFE_INTEGER,
|
|
});
|
|
});
|
|
|
|
// Sort if a sort function is provided
|
|
return sortFn ? customAttrs.sort(sortFn) : customAttrs;
|
|
};
|
|
|
|
/**
|
|
* Convert display values back to option IDs for select/multiselect fields
|
|
* @param displayValue - The display value (option names)
|
|
* @param fieldType - The field type ('select' or 'multiselect')
|
|
* @param optionsMap - Map of option IDs to option names
|
|
* @returns The option IDs as string (select) or JSON array string (multiselect)
|
|
*/
|
|
export const convertDisplayValueToOptionIds = (displayValue: string, fieldType: string, optionsMap: Record<string, string>): string => {
|
|
if (!displayValue || !optionsMap) {
|
|
return displayValue;
|
|
}
|
|
|
|
// Create reverse map (option names to IDs)
|
|
const reverseOptionsMap: Record<string, string> = {};
|
|
Object.entries(optionsMap).forEach(([id, name]) => {
|
|
reverseOptionsMap[name] = id;
|
|
});
|
|
|
|
if (fieldType === 'select') {
|
|
// Single select: return the option ID for the name
|
|
return reverseOptionsMap[displayValue] || displayValue;
|
|
}
|
|
|
|
if (fieldType === 'multiselect') {
|
|
// Multi-select: split display names and convert to IDs
|
|
const optionNames = displayValue.split(',').map((name) => name.trim()).filter((name) => name !== '');
|
|
const optionIds = optionNames.map((name) => reverseOptionsMap[name] || name);
|
|
return JSON.stringify(optionIds);
|
|
}
|
|
|
|
return displayValue;
|
|
};
|
|
|
|
/**
|
|
* Get selected option IDs from a custom attribute value
|
|
* @param value - The stored value (option ID or JSON array string)
|
|
* @param fieldType - The field type ('select' or 'multiselect')
|
|
* @returns Array of selected option IDs
|
|
*/
|
|
export const getSelectedOptionIds = (value: string, fieldType: string): string[] => {
|
|
if (!value) {
|
|
return [];
|
|
}
|
|
|
|
if (fieldType === 'select') {
|
|
return [value];
|
|
}
|
|
|
|
if (fieldType === 'multiselect') {
|
|
try {
|
|
const parsed: unknown = safeParseJSON(value);
|
|
if (Array.isArray(parsed)) {
|
|
return parsed;
|
|
}
|
|
|
|
// Fallback to comma-separated string
|
|
return value.split(',').map((id) => id.trim()).filter((id) => id !== '');
|
|
} catch (error) {
|
|
return value.split(',').map((id) => id.trim()).filter((id) => id !== '');
|
|
}
|
|
}
|
|
|
|
return [];
|
|
};
|
|
|
|
/**
|
|
* Format field options for use with AutocompleteSelector component
|
|
* @param field - The custom profile field
|
|
* @returns Array of DialogOption objects for the selector
|
|
*/
|
|
export const formatOptionsForSelector = (field: CustomProfileFieldModel): DialogOption[] => {
|
|
if (!field.attrs || (field.type !== 'select' && field.type !== 'multiselect')) {
|
|
return [];
|
|
}
|
|
|
|
const options = field.attrs.options as Array<{id: string; name: string}> | undefined;
|
|
if (!options || !Array.isArray(options)) {
|
|
return [];
|
|
}
|
|
|
|
return options.map((option) => ({
|
|
text: option.name,
|
|
value: option.id,
|
|
}));
|
|
};
|
|
|
|
/**
|
|
* Convert selected option IDs to the format expected by the server
|
|
* @param value - The stored value (option ID or JSON array string)
|
|
* @param fieldType - The field type ('select' or 'multiselect')
|
|
* @returns String for select, array for multiselect
|
|
*/
|
|
export const convertValueForServer = (value: string, fieldType: string): string|string[] => {
|
|
if (fieldType !== 'multiselect') {
|
|
return value;
|
|
}
|
|
if (!value) {
|
|
return [];
|
|
}
|
|
|
|
try {
|
|
const parsed = JSON.parse(value);
|
|
if (Array.isArray(parsed)) {
|
|
return parsed;
|
|
}
|
|
} catch {
|
|
const parsed = value.split(',').map((id) => id.trim()).filter((id) => id !== '');
|
|
return parsed;
|
|
}
|
|
return [];
|
|
};
|
|
|
|
/**
|
|
* Convert server response values to the format expected by the UI
|
|
* @param value - The value from server (string or array)
|
|
* @param fieldType - The field type ('select' or 'multiselect')
|
|
* @returns String representation for UI storage
|
|
*/
|
|
export const convertValueFromServer = (value: string | string[], fieldType: string): string => {
|
|
if (value === null || value === undefined) {
|
|
return '';
|
|
}
|
|
|
|
if (fieldType === 'select') {
|
|
return Array.isArray(value) ? (value[0] || '') : String(value);
|
|
}
|
|
|
|
if (fieldType === 'multiselect') {
|
|
if (Array.isArray(value)) {
|
|
try {
|
|
return JSON.stringify(value);
|
|
} catch (error) {
|
|
logError('Error converting value from server to string', error);
|
|
return '';
|
|
}
|
|
}
|
|
|
|
return String(value);
|
|
}
|
|
|
|
return String(value);
|
|
};
|
|
|
|
export const isCustomFieldSamlLinked = (customField?: CustomProfileFieldModel): boolean => {
|
|
return Boolean(customField?.attrs?.saml);
|
|
};
|