@plusscommunities/pluss-circles-app-groups 1.2.2-beta.0

package/src/feature.config.js

@@ -0,0 +1,274 @@
+import _ from 'lodash';
+// import * as PlussCore from '../../pluss-core/src';
+import * as PlussCore from '@plusscommunities/pluss-core-app';
+import { CIRCLE_INVITES_LOADED, CIRCLES_LOAD_INITIALISE, UPDATE_CIRCLE_UNREAD } from './actions/types';
+import { getSessionTokenAWS, mapStateToDirectMessages } from './js';
+import { circleActions } from './webapi';
+import { refreshGroups } from './actions';
+import { values } from './values.config';
+
+export const Services = {
+  navigation: null,
+};
+
+export const BaseComponents = {
+  NotificationBell: null,
+};
+
+const INVITE_KEY = values.inviteKey;
+const MESSAGE_KEY = values.messageKey;
+const CHAT_TYPE = values.notificationMessage;
+const CHAT_ROUTE = values.chatRoute;
+
+const getInvites = state => {
+  return state[values.reducerKey].invites.map(invite => {
+    invite.InviteType = INVITE_KEY;
+    invite.Timestamp = invite.CreatedTime;
+    return invite;
+  });
+};
+
+const getMessages = state => {
+  const circles = state[values.reducerKey];
+  const { user } = state;
+
+  let messages = [];
+  if (user.uid != null) {
+    circles.list.forEach(element => {
+      if (
+        !element.Deleted &&
+        !_.isUndefined(element.Unread) &&
+        !_.isEmpty(element.Unread) &&
+        !_.isUndefined(element.Unread[user.uid]) &&
+        element.Unread[user.uid] > 0
+      ) {
+        messages.push({
+          ...element,
+          MessageType: MESSAGE_KEY,
+          Timestamp: element.Changed * 1000,
+        });
+      }
+    });
+    circles.privateList.forEach(element => {
+      if (
+        !element.Deleted &&
+        !!element.PrivateChatUser &&
+        !_.isUndefined(element.Unread) &&
+        !_.isEmpty(element.Unread) &&
+        !_.isUndefined(element.Unread[user.uid]) &&
+        element.Unread[user.uid] > 0
+      ) {
+        messages.push({
+          ...element,
+          isPrivate: true,
+          MessageType: MESSAGE_KEY,
+          Timestamp: element.Changed * 1000,
+        });
+      }
+    });
+  }
+
+  return _.orderBy(messages, 'Changed', 'desc');
+};
+
+const getCount = state => {
+  const circles = state[values.reducerKey];
+  const { user } = state;
+  const inviteCount = circles?.invites?.length || 0;
+
+  let circleUnread = 0;
+  if (user.uid != null) {
+    circles.list.forEach(element => {
+      if (
+        !_.isUndefined(element.Unread) &&
+        !_.isEmpty(element.Unread) &&
+        !_.isUndefined(element.Unread[user.uid]) &&
+        element.Unread[user.uid] > 0
+      ) {
+        circleUnread += 1;
+      }
+    });
+    circles.privateList.forEach(element => {
+      if (
+        !!element.PrivateChatUser &&
+        !_.isUndefined(element.Unread) &&
+        !_.isEmpty(element.Unread) &&
+        !_.isUndefined(element.Unread[user.uid]) &&
+        element.Unread[user.uid] > 0
+      ) {
+        circleUnread += 1;
+      }
+    });
+  }
+
+  // console.log('circles', inviteCount, circleUnread);
+  return inviteCount + circleUnread;
+};
+
+const getUserCircles = async (props, store) => {
+  // Get user circles
+  const { data } = await circleActions.getGroups();
+  store.dispatch({
+    type: CIRCLES_LOAD_INITIALISE,
+    payload: data.Items,
+  });
+  // Update unread
+  if (!_.isEmpty(data.Items)) {
+    let counter = 0;
+    data.Items.forEach(element => {
+      if (
+        !element.Deleted &&
+        !_.isUndefined(element.Unread) &&
+        !_.isEmpty(element.Unread) &&
+        !_.isUndefined(element.Unread[props.user.uid])
+      ) {
+        counter += element.Unread[props.user.uid];
+      }
+    });
+    store.dispatch({
+      type: UPDATE_CIRCLE_UNREAD,
+      payload: counter,
+    });
+  }
+};
+
+const fetchAll = async (props, store) => {
+  try {
+    // Get circle invites
+    const token = await getSessionTokenAWS('Bearer');
+    const { data } = await circleActions.getGroupInvites(props.user.uid, token);
+    store.dispatch({
+      type: CIRCLE_INVITES_LOADED,
+      payload: data.Items,
+    });
+
+    await getUserCircles(props, store);
+  } catch (error) {
+    console.error('pluss-circles fetch all', error);
+  }
+};
+
+const fetchToaster = (props, store) => {
+  try {
+    const { notification } = props;
+    if (notification.data.type === CHAT_TYPE || notification.data.type === values.notificationDirectMessage) {
+      setTimeout(async () => {
+        await getUserCircles(props, store);
+      }, 100);
+      return true;
+    }
+  } catch (error) {
+    console.error('pluss-circles fetch toaster', error);
+  }
+  return false;
+};
+
+const handle = (notification, props, currentRoute) => {
+  if (notification.data.type === CHAT_TYPE) {
+    if (currentRoute !== CHAT_ROUTE) props.displayToast(notification);
+    return true;
+  }
+  return false;
+};
+
+const navigate = (notification, currentRoute, refreshFunc, navigateFunc) => {
+  if (notification.data.type === CHAT_TYPE) {
+    const prop = {
+      chat: {
+        key: notification.data.key,
+        Id: notification.data.key,
+      },
+    };
+    if (currentRoute === CHAT_ROUTE) {
+      refreshFunc(prop);
+    } else {
+      navigateFunc(CHAT_ROUTE, prop);
+    }
+    return true;
+  }
+  return false;
+};
+
+const openDirectMessage = (site, targetUserId, chat, loadingChanged) => {
+  if (chat) {
+    Services.navigation.navigate(values.screenCircleChat, { chat });
+  } else {
+    loadingChanged && loadingChanged(true);
+    circleActions.getDirect(site, targetUserId).then(res => {
+      Services.navigation.navigate(values.screenCircleChat, { chat: res.data });
+      loadingChanged && loadingChanged(false);
+    });
+  }
+};
+
+const FeatureConfig = {
+  key: values.featureKey,
+  title: values.textFeatureTitle,
+  gridMenu: {
+    icon: 'groups',
+    viewBox: '0 0 30 30',
+    navigate: values.screenCirclePeopleContainer,
+    options: {
+      onlyGroups: true,
+    },
+  },
+  addMenu: {
+    order: 5,
+    icon: 'groups',
+    title: values.textAddMenuTitle,
+    navigate: values.screenNewCircle,
+    visibleExps: values.settings.allowAnyCreate
+      ? { type: 'feature', value: values.featureKey }
+      : {
+          type: 'and',
+          exps: [
+            { type: 'feature', value: values.featureKey },
+            { type: 'permission', value: values.permission },
+          ],
+        },
+  },
+  notification: {
+    invite: {
+      key: INVITE_KEY,
+      getInvites,
+    },
+    message: {
+      key: MESSAGE_KEY,
+      getMessages,
+    },
+    getCount,
+    fetchAll,
+    fetchToaster,
+    handle,
+    navigate,
+  },
+  messaging: {
+    openDirectMessage,
+    mapStateToDirectMessages,
+    refreshChats: refreshGroups,
+  },
+  hideTabBar: [values.screenNewCircle, values.screenCircleDetails, values.screenEditCircle],
+  env: {
+    baseStage: '',
+    baseAPIUrl: '',
+    hasGradientHeader: false,
+    defaultProfileImage: '',
+    tinyChatDefault: '',
+    baseUploadsUrl: '',
+    allowMediaDownload: false,
+    allowMediaSharing: false,
+    awsUploadsBucket: '',
+    awsStorageBucket: '',
+    preferredSite: '',
+    strings: {},
+    newEventDefaults: '',
+    defaultAllowComments: true,
+  },
+  init: (environment, navigation, notificationBell) => {
+    FeatureConfig.env = environment;
+    Services.navigation = navigation;
+    BaseComponents.NotificationBell = notificationBell;
+    PlussCore.Config.init(environment, navigation);
+  },
+};
+export default FeatureConfig;

package/src/index.js

@@ -0,0 +1,24 @@
+import NewGroup from './components/groups/NewGroup';
+import GroupDetails from './components/groups/GroupDetails';
+import EditGroup from './components/groups/EditGroup';
+import PeopleContainer from './components/chat/PeopleContainer';
+import Chat from './components/chat/Chat';
+import ChatList from './components/chat/ChatList';
+import GroupsReducer from './reducers/GroupsReducer';
+import ChatsReducer from './reducers/ChatsReducer';
+import { values } from './values.config';
+
+export const Reducers = { [values.reducerKey]: GroupsReducer, [values.reducerKeyChats]: ChatsReducer };
+export const Screens = {
+  [values.screenNewCircle]: NewGroup,
+  [values.screenCircleDetails]: GroupDetails,
+  [values.screenEditCircle]: EditGroup,
+  [values.screenCirclePeopleContainer]: PeopleContainer,
+  [values.screenCircleChat]: Chat,
+  [values.screenCircleChatList]: ChatList,
+};
+export { default as Config } from './feature.config';
+export { default as WidgetSmall } from './components/groups/GroupsWidget';
+export { default as WidgetLarge } from './components/groups/GroupsList';
+export { default as NotificationInvite } from './components/notifications/GroupInvite';
+export { default as NotificationMessage } from './components/notifications/GroupMessage';

package/src/js/Colors.js

@@ -0,0 +1,17 @@
+import { Colours } from '../core.config';
+
+export const getMainBrandingColourFromState = Colours.getMainBrandingColourFromState;
+export const getLightBrandingColourFromState = Colours.getLightBrandingColourFromState;
+export const LINEGREY = Colours.LINEGREY;
+export const TEXT_DARKEST = Colours.TEXT_DARKEST;
+export const TEXT_DARK = Colours.TEXT_DARK;
+export const TEXT_MID = Colours.TEXT_MID;
+export const TEXT_LIGHT = Colours.TEXT_LIGHT;
+export const TEXT_LIGHTER = Colours.TEXT_LIGHTER;
+export const TEXT_BLUEGREY = Colours.TEXT_BLUEGREY;
+export const COLOUR_GREEN = Colours.COLOUR_GREEN;
+export const COLOUR_TRANSPARENT = Colours.COLOUR_TRANSPARENT;
+export const COLOUR_TEAL = Colours.COLOUR_TEAL;
+export const COLOUR_PURPLE = Colours.COLOUR_PURPLE;
+export const COLOUR_TANGERINE = Colours.COLOUR_TANGERINE;
+export const COLOUR_DUSK = Colours.COLOUR_DUSK;

package/src/js/NavigationService.js

@@ -0,0 +1,9 @@
+import { Services } from '../feature.config';
+
+const navService = {
+  navigate: (routeName, params) => Services.navigation.navigate(routeName, params),
+  goBack: routeName => Services.navigation.goBack(routeName),
+  getParentRoute: () => Services.navigation.getParentRoute(),
+};
+
+export default navService;

package/src/js/Styles.js

@@ -0,0 +1,3 @@
+import { Styles } from '../core.config';
+
+export default Styles;

package/src/js/circles/MapStateToDirectMessages.js

@@ -0,0 +1,10 @@
+import _ from 'lodash';
+import { values } from '../../values.config';
+
+const mapStateToDirectMessages = state => {
+  return _.filter(state[values.reducerKey].list, c => {
+    return c.IsPrivate;
+  });
+};
+
+export default mapStateToDirectMessages;

package/src/js/index.js

@@ -0,0 +1,24 @@
+import { Session, Helper } from '../core.config';
+import mapStateToDirectMessages from './circles/MapStateToDirectMessages';
+
+// Session
+export const authedFunction = Session.authedFunction;
+export const getSessionTokenAWS = Session.getSessionTokenAWS;
+export const getSessionUidAWS = Session.getSessionUidAWS;
+
+// Helper
+export const getFirstName = Helper.getFirstName;
+export const getFileName = Helper.getFileName;
+export const getImageSource = Helper.getImageSource;
+export const StatusBarHeight = Helper.StatusBarHeight;
+export const getPluralS = Helper.getPluralS;
+export const getShadowStyle = Helper.getShadowStyle;
+export const getSite = Helper.getSite;
+export const getSiteSettingFromState = Helper.getSiteSettingFromState;
+export const getValueOrDefault = Helper.getValueOrDefault;
+export const usersToSearchResult = Helper.usersToSearchResult;
+export const searchUsers = Helper.searchUsers;
+
+export { mapStateToDirectMessages };
+
+export * from './Colors';

package/src/reducers/ChatsReducer.js

@@ -0,0 +1,63 @@
+import { REHYDRATE } from 'redux-persist';
+import {
+  SOFT_ADD_CIRCLE_CHAT,
+  CREATED_CIRCLE_CHAT,
+  RECEIVED_CIRCLE_CHATS,
+  RECEIVED_CIRCLE_MESSAGES,
+  RECEIVED_BLOCKED_CIRCLE_USERS,
+  LOGOUT,
+  CHANGE_ROLE,
+} from '../actions/types';
+import { CHAT_REDUCER_KEY } from './reducerKeys';
+
+const INITIAL_STATE = {
+  selectedChatKey: null,
+  list: [],
+  messages: {},
+  unreadCount: 0,
+  blockedUsers: {},
+};
+
+export default (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case LOGOUT:
+    case CHANGE_ROLE:
+      return INITIAL_STATE;
+    case CREATED_CIRCLE_CHAT:
+      return { ...state, selectedChatKey: action.payload, messages: [] };
+    case SOFT_ADD_CIRCLE_CHAT:
+      return { ...state, list: [...state.list, ...action.payload] };
+    case RECEIVED_CIRCLE_CHATS:
+      return { ...state, list: action.payload, unreadCount: action.unreadCount };
+    case RECEIVED_CIRCLE_MESSAGES:
+      return { ...state, messages: { ...state.messages, [action.payload.chatKey]: action.payload.messages } };
+    case RECEIVED_BLOCKED_CIRCLE_USERS:
+      return { ...state, blockedUsers: action.payload };
+
+    case REHYDRATE:
+      if (!action.payload) return state;
+      if (action.payload[CHAT_REDUCER_KEY] && Array.isArray(action.payload[CHAT_REDUCER_KEY])) {
+        return {
+          list: action.payload[CHAT_REDUCER_KEY],
+          // areas: _.groupBy(action.payload[CHAT_REDUCER_KEY], (event) => { return event.Area })
+        };
+      } else if (action.payload[CHAT_REDUCER_KEY]) {
+        if (action.payload[CHAT_REDUCER_KEY].messages == null) {
+          action.payload[CHAT_REDUCER_KEY].messages = {};
+        }
+        if (action.payload[CHAT_REDUCER_KEY].unreadCount == null) {
+          action.payload[CHAT_REDUCER_KEY].unreadCount = 0;
+        }
+        if (action.payload[CHAT_REDUCER_KEY].blockedUsers == null) {
+          action.payload[CHAT_REDUCER_KEY].blockedUsers = {};
+        }
+        /* fixSelectedTimes(action.payload[CHAT_REDUCER_KEY].list);
+                fixRepeatedTimes(action.payload[CHAT_REDUCER_KEY].list); */
+        return action.payload[CHAT_REDUCER_KEY];
+      }
+      return state;
+
+    default:
+      return state;
+  }
+};

package/src/reducers/GroupsReducer.js

@@ -0,0 +1,142 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-case-declarations */
+import { REHYDRATE } from 'redux-persist';
+import _ from 'lodash';
+import {
+  LOGOUT,
+  CIRCLE_INVITES_LOADED,
+  CIRCLE_INVITES_UPDATED,
+  PUBLIC_CIRCLES_LOAD_INITIALISE,
+  CIRCLES_LOAD_INITIALISE,
+  CIRCLES_LOADED,
+  CREATED_CIRCLE,
+  CLEAR_CIRCLES,
+  UPDATE_CIRCLE_UNREAD,
+  CLEAR_SINGLE_CIRCLE_UNREAD,
+  CHANGE_ROLE,
+} from '../actions/types';
+import { GROUPS_REDUCER_KEY } from './reducerKeys';
+
+const INITIAL_STATE = {
+  list: [],
+  publicList: [],
+  privateList: [],
+  invites: [],
+  unreadCount: 0,
+  privateCount: 0,
+};
+
+export default (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case LOGOUT:
+    case CHANGE_ROLE:
+      return INITIAL_STATE;
+    case UPDATE_CIRCLE_UNREAD: {
+      return { ...state, unreadCount: action.payload };
+    }
+    case CLEAR_SINGLE_CIRCLE_UNREAD: {
+      const growps = [...state.list];
+      let newCount = state.unreadCount;
+      if (!_.isEmpty(growps)) {
+        growps.forEach(g => {
+          if (!g.Unread) {
+            g.Unread = {};
+          }
+          if (g.Id === action.payload.groupId) {
+            g.Unread[action.payload.userId] = 0;
+          }
+        });
+        let counter = 0;
+        growps.forEach(element => {
+          if (!_.isUndefined(element.Unread) && !_.isEmpty(element.Unread) && !_.isUndefined(element.Unread[action.payload.userId])) {
+            counter += element.Unread[action.payload.userId];
+          }
+        });
+        newCount = counter;
+      }
+      return { ...state, list: growps, unreadCount: newCount };
+    }
+    case CIRCLE_INVITES_LOADED:
+      if (action.payload == null) {
+        return state;
+      }
+      return { ...state, invites: action.payload };
+    case CIRCLE_INVITES_UPDATED:
+      if (action.payload == null || action.payload.length === 0) {
+        return state;
+      }
+      let pInvites = [...state.invites];
+      if (pInvites === null) pInvites = [];
+
+      let pInvResult = _.unionWith(action.payload, pInvites, (v1, v2) => {
+        return v1 != null && v2 != null && v1.Id === v2.Id;
+      });
+
+      pInvResult = _.filter(pInvResult, group => {
+        return group != null && !group.Deleted;
+      });
+      return { ...state, invites: pInvResult };
+    case PUBLIC_CIRCLES_LOAD_INITIALISE:
+      // console.log('PUBLIC_CIRCLES_LOAD_INITIALISE', action.payload);
+      if (action.payload == null) {
+        return state;
+      }
+      return { ...state, publicList: action.payload };
+    case CIRCLES_LOAD_INITIALISE:
+      if (action.payload == null) {
+        return state;
+      }
+      // return { ...state, list: action.payload };
+      return {
+        ...state,
+        list: _.filter(action.payload, group => {
+          return group != null && !group.Deleted;
+        }),
+      };
+    case CIRCLES_LOADED:
+      if (action.payload == null || action.payload.length === 0) {
+        return state;
+      }
+      let pGroups = state.list;
+      if (pGroups === null) pGroups = [];
+
+      let pResult = _.unionWith(action.payload, pGroups, (v1, v2) => {
+        return v1 != null && v2 != null && v1.Id === v2.Id;
+      });
+
+      pResult = _.filter(pResult, group => {
+        return group != null && !group.Deleted;
+      });
+      return {
+        ...state,
+        list: _.filter(pResult, group => {
+          return group != null && !group.Deleted;
+        }),
+      };
+    case CREATED_CIRCLE:
+      const zzzz = [...state.list];
+      zzzz.push(action.payload);
+      return { ...state, list: zzzz };
+    case CLEAR_CIRCLES:
+      return { list: [], invites: [] };
+    case REHYDRATE:
+      if (!action.payload) return state;
+      if (action.payload[GROUPS_REDUCER_KEY]) {
+        if (action.payload[GROUPS_REDUCER_KEY].list == null) {
+          action.payload[GROUPS_REDUCER_KEY].list = [];
+        }
+        if (action.payload[GROUPS_REDUCER_KEY].invites == null) {
+          action.payload[GROUPS_REDUCER_KEY].invites = [];
+        }
+        if (action.payload[GROUPS_REDUCER_KEY].unreadCount == null) {
+          action.payload[GROUPS_REDUCER_KEY].unreadCount = 0;
+        }
+        /* fixSelectedTimes(action.payload[GROUPS_REDUCER_KEY].list);
+                fixRepeatedTimes(action.payload[GROUPS_REDUCER_KEY].list); */
+        return action.payload[GROUPS_REDUCER_KEY];
+      }
+      return state;
+    default:
+      return state;
+  }
+};

package/src/reducers/reducerKeys.js

@@ -0,0 +1,4 @@
+import { values } from '../values.config';
+
+export const GROUPS_REDUCER_KEY = values.reducerKey;
+export const CHAT_REDUCER_KEY = values.reducerKeyChats;

package/src/values.config.default.js

@@ -0,0 +1,39 @@
+const values = {
+  featureKey: 'circles',
+  entityKey: 'circle',
+  entityName: 'circle',
+  serviceKey: 'circles',
+  permission: 'circles',
+
+  reducerKey: 'circles',
+  reducerKeyChats: 'circleChats',
+
+  actionCircleKey: 'CIRCLE',
+
+  screenNewCircle: 'newCircle',
+  screenCircleDetails: 'circleDetails',
+  screenEditCircle: 'editCircle',
+  screenCirclePeopleContainer: 'circlePeopleContainer',
+  screenCircleChat: 'circleChat',
+  screenCircleChatList: 'circleChatList',
+
+  notificationInvite: 'CircleInvite',
+  notificationMessage: 'CircleChat',
+  notificationDirectMessage: 'CircleProfileChat',
+
+  textFeatureTitle: 'Circles',
+  textAddMenuTitle: 'Circle',
+  textEmptyGroups: "You aren't in any Circles",
+  textEmptyPeople: 'Contacts will show here',
+
+  inviteKey: 'circleInvite',
+  messageKey: 'circleMessage',
+  chatRoute: 'circleChat',
+  updateKeyUserCircles: 'userCircles',
+  allowPublicKey: 'circleAllowPublicCircles',
+
+  settings: {
+    allowAnyCreate: false,
+  },
+};
+exports.values = values;

package/src/values.config.groups.js

@@ -0,0 +1,39 @@
+const values = {
+  featureKey: 'groups',
+  entityKey: 'group',
+  entityName: 'group',
+  serviceKey: 'groups',
+  permission: 'groups',
+
+  reducerKey: 'groups',
+  reducerKeyChats: 'groupChats',
+
+  actionCircleKey: 'GROUP',
+
+  screenNewCircle: 'newGroup',
+  screenCircleDetails: 'groupDetails',
+  screenEditCircle: 'editGroup',
+  screenCirclePeopleContainer: 'groupPeopleContainer',
+  screenCircleChat: 'groupChat',
+  screenCircleChatList: 'groupChatList',
+
+  notificationInvite: 'GroupInvite',
+  notificationMessage: 'GroupChat',
+  notificationDirectMessage: 'GroupProfileChat',
+
+  textFeatureTitle: 'Groups',
+  textAddMenuTitle: 'Group',
+  textEmptyGroups: "You aren't in any Groups",
+  textEmptyPeople: 'Contacts will show here',
+
+  inviteKey: 'groupInvite',
+  messageKey: 'groupMessage',
+  chatRoute: 'groupChat',
+  updateKeyUserCircles: 'userGroups',
+  allowPublicKey: 'groupAllowPublicGroups',
+
+  settings: {
+    allowAnyCreate: true,
+  },
+};
+exports.values = values;

package/src/values.config.js

@@ -0,0 +1,39 @@
+const values = {
+  featureKey: 'groups',
+  entityKey: 'group',
+  entityName: 'group',
+  serviceKey: 'groups',
+  permission: 'groups',
+
+  reducerKey: 'groups',
+  reducerKeyChats: 'groupChats',
+
+  actionCircleKey: 'GROUP',
+
+  screenNewCircle: 'newGroup',
+  screenCircleDetails: 'groupDetails',
+  screenEditCircle: 'editGroup',
+  screenCirclePeopleContainer: 'groupPeopleContainer',
+  screenCircleChat: 'groupChat',
+  screenCircleChatList: 'groupChatList',
+
+  notificationInvite: 'GroupInvite',
+  notificationMessage: 'GroupChat',
+  notificationDirectMessage: 'GroupProfileChat',
+
+  textFeatureTitle: 'Groups',
+  textAddMenuTitle: 'Group',
+  textEmptyGroups: "You aren't in any Groups",
+  textEmptyPeople: 'Contacts will show here',
+
+  inviteKey: 'groupInvite',
+  messageKey: 'groupMessage',
+  chatRoute: 'groupChat',
+  updateKeyUserCircles: 'userGroups',
+  allowPublicKey: 'groupAllowPublicGroups',
+
+  settings: {
+    allowAnyCreate: true,
+  },
+};
+exports.values = values;