@nlabs/reaktor 0.10.5 → 0.10.7

package/lib/actions/posts.js

@@ -0,0 +1,608 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseNum } from '@nlabs/utils/parsers/numbers';
+import { createHash, parseArangoId, parseChar, parseId, parseString, parseVarChar } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import { parsePost } from '../adapters/postAdapter.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError, logException } from '../utils/analyticsUtils.js';
+import { getLimit, useDb } from '../utils/arangodbUtils.js';
+import { extractTags, getTagsByName, updateTagsInItem } from './tags.js';
+const MAX_CONTENT_LENGTH = 100000;
+const eventCategory = 'posts';
+export const parsePostOptions = (options = {})=>{
+    const { from = 0, latitude = 0, longitude = 0, to = 30, type = 'post' } = options;
+    return {
+        latitude: parseNum(latitude, 32),
+        limit: getLimit(from, to),
+        longitude: parseNum(longitude, 32),
+        type: parseChar(type, 32)
+    };
+};
+export const getPostOptional = (fields = [], sessionId = '')=>(fields || []).reduce((selects, field)=>{
+        switch(field){
+            case 'hasRsvp':
+                {
+                    selects.queries.push(`LET hasRsvp = TO_BOOL(FIRST(
+          FOR post, r IN INBOUND p._id hasReaction
+          FILTER r.name == "rsvp" && r.type == "posts" && r._from == "users/${sessionId}"
+          COLLECT WITH COUNT INTO count
+          RETURN count
+        ))`);
+                    selects.objects.push('hasRsvp:hasRsvp');
+                    return selects;
+                }
+            case 'isSaved':
+                {
+                    selects.queries.push(`LET isSaved = TO_BOOL(FIRST(
+          FOR post, r IN INBOUND p._id hasReaction
+          FILTER r.name == "pin" && r.type == "posts" && r._from == "users/${sessionId}"
+          COLLECT WITH COUNT INTO count
+          RETURN count
+        ))`);
+                    selects.objects.push('isSaved:isSaved');
+                    return selects;
+                }
+            case 'reactions':
+                {
+                    selects.queries.push(`LET reactions = (
+          FOR post, r IN INBOUND p._id hasReaction
+          COLLECT reactionName = r.value INTO reactionItems
+          RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
+        )`);
+                    selects.objects.push('reactions:reactions');
+                    return selects;
+                }
+            case 'rsvpCount':
+                {
+                    selects.queries.push(`LET rsvpCount = FIRST(
+          FOR post, r IN INBOUND p._id hasReaction
+          FILTER r.name == "rsvp" && r.type == "posts"
+          COLLECT WITH COUNT INTO count
+          RETURN count
+        )`);
+                    selects.objects.push('rsvpCount:rsvpCount');
+                    return selects;
+                }
+            case 'viewCount':
+                {
+                    selects.queries.push(`LET viewCount = FIRST(
+          FOR post, r IN INBOUND p._id hasReaction
+          FILTER r.name == "view" && r.type == "posts"
+          COLLECT WITH COUNT INTO count
+          RETURN count
+        )`);
+                    selects.objects.push('viewCount:viewCount');
+                    return selects;
+                }
+            default:
+                {
+                    return selects;
+                }
+        }
+    }, {
+        objects: [],
+        queries: []
+    });
+export const getPost = async (context, postId, options)=>{
+    const action = 'getPost';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const formatItemId = parseId(postId);
+    const { type } = parsePostOptions(options);
+    const database = useDb(databaseName);
+    const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+    const aqlQry = aql`FOR p IN posts
+    FILTER p._key == ${formatItemId} && p.type == ${type}
+    LIMIT 1
+    RETURN p`;
+    return database.query(aqlQry).then((cursor)=>cursor.next()).then((post)=>{
+        const { _id: postDocId, userId, groupId, privacy = 'default' } = post;
+        let privacyAqlQry;
+        if (userId === sessionId) {
+            return post;
+        }
+        if (groupId && privacy === 'group') {
+            privacyAqlQry = `LET p = DOCUMENT("${postDocId}")
+          ${selectQueries.join('\n')}
+          FOR group IN groups
+          FILTER group._key == p.groupId
+          FOR u, e IN OUTBOUND group._id hasConnection
+          FILTER u._key == "${sessionId}"
+          LIMIT 1
+          RETURN MERGE(p, {${selectObjects.join(', ')}})`;
+        } else if (privacy === 'public') {
+            privacyAqlQry = `LET p = DOCUMENT("${postDocId}")
+          ${selectQueries.join('\n')}
+          LIMIT 1
+          RETURN MERGE(p, {${selectObjects.join(', ')}})`;
+        }
+        if (privacyAqlQry) {
+            return database.query(privacyAqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                    action,
+                    category: eventCategory,
+                    label: ErrorTypes.DATABASE_ERROR
+                }, error, context));
+        }
+        return {};
+    }).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+// export const getPostList = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {
+//   // const action: string = 'getListByApp';
+//   const {database, fields, session: {userId: sessionId}} = context;
+//   const {limit, type} = parsePostOptions(options);
+//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);
+//   const aqlQry: string = `FOR p IN posts
+//     FILTER p.type == "${type}" && p.privacy == "public" && p.parent == null
+//     ${selectQueries.join('\n')}
+//     ${limit.aql}
+//     SORT p.added
+//     RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+//   return database.query(aqlQry)
+//     .then((cursor) => cursor.all())
+//     .catch((error: Error) => {
+//       throw error;
+//     });
+// };
+export const getPostsByArea = (context, latitude, longitude, options)=>{
+    const action = 'getPostsByArea';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const { limit, type } = parsePostOptions(options);
+    const formatLatitude = parseNum(latitude);
+    const formatLongitude = parseNum(longitude);
+    const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+    selectQueries.push(`LET distance = DISTANCE(
+    ${formatLatitude},
+    ${formatLongitude},
+    NOT_NULL(p.latitude, 0),
+    NOT_NULL(p.longitude, 0))
+  `);
+    selectObjects.push('distance:distance');
+    const aqlQry = `FOR p IN posts
+    ${selectQueries.join('\n')}
+    FILTER p.type == "${type}" && p.privacy == "public" && p.parentId == null
+    ${limit.aql}
+    SORT distance, p.added
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+// export const getPostsByGroup = (
+//   context: ApiContext,
+//   groupId: string,
+//   options?: PostOptions
+// ): Promise<PostType[]> => {
+//   // const action: string = 'getListByGroup';
+//   const {database, fields, session: {userId: sessionId}} = context;
+//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);
+//   // Group id
+//   const formatGroupId: string = parseId(groupId);
+//   const db = database;
+//   const aqlQry: string = `FOR u, g IN INBOUND ${formatGroupId} hasGroup
+//       FILTER u._key == ${sessionId}
+//       RETURN g`;
+//   return db.query(aqlQry)
+//     .then((cursor) => cursor.all())
+//     .then((groups: GroupType[] = []) => {
+//       if(groups.length) {
+//         const {limit, type} = parsePostOptions(options);
+//         const postAqlQry: string = `FOR p IN posts
+//           FILTER p.type == "${type}" && p.groupId == "${formatGroupId}" && p.parent == null
+//           ${selectQueries.join('\n')}
+//           ${limit.aql}
+//           SORT p.added
+//           RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+//         return db.query(postAqlQry)
+//           .then((cursor) => cursor.all())
+//           .catch((error: Error) => {
+//             throw error;
+//           });
+//       }
+//       return [];
+//     })
+//     .catch((error: Error) => {
+//       throw error;
+//     });
+// };
+export const getPostsByLatest = (context, options)=>{
+    // const action: string = 'getListByLatest';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const { limit, type } = parsePostOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+    const aqlQry = `FOR p IN posts
+    FILTER p.type == "${type}" && p.privacy == "public" && p.parent == null
+    ${selectQueries.join('\n')}
+    ${limit.aql}
+    SORT p.added DESC
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        throw error;
+    });
+};
+export const getPostsByReactions = (context, reactions = [], options)=>{
+    const action = 'getPostsByReactions';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const { latitude, limit, longitude, type } = parsePostOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+    const formatSessionId = `users/${sessionId}`;
+    const formatReactions = JSON.stringify(reactions.map((reaction)=>parseChar(reaction, 32).toLowerCase()));
+    const sortBy = [];
+    const filters = [
+        `p.type == "${type}"`,
+        'p.privacy == "public"'
+    ];
+    const formatLatitude = parseNum(latitude);
+    const formatLongitude = parseNum(longitude);
+    if (formatLatitude && formatLongitude) {
+        selectQueries.push(`LET distance = DISTANCE(
+      ${formatLatitude},
+      ${formatLongitude},
+      NOT_NULL(p.latitude, 0),
+      NOT_NULL(p.longitude, 0))
+    `);
+        selectObjects.push('distance:distance');
+        sortBy.push('distance');
+    }
+    if (reactions.length) {
+        sortBy.push('matchedTags DESC');
+        selectQueries.push(`LET matchedReactions = LENGTH(
+      FOR mr IN reactions
+      FILTER mr.matched == true
+      RETURN mr
+    )`);
+        selectObjects.push('matchedReactions:matchedReactions');
+        filters.push('matchedReactions > 0');
+    }
+    sortBy.push('p.added DESC');
+    selectObjects.push('reactions:reactions');
+    // Get data from database
+    const aqlQry = `FOR p, r IN OUTBOUND "${formatSessionId}" hasReaction
+    LET reactions = (
+      FOR reaction, hr IN 1..1 INBOUND p isTagged
+      LET matched = LENGTH(${formatReactions}) > 0 && POSITION(${formatReactions}, reaction.name)
+      SORT reaction.name
+      RETURN MERGE(reaction, {matched:matched})
+    )
+    ${selectQueries.join('\n')}
+    FILTER ${filters.join(' && ')}
+    ${limit.aql}
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getPostsByTags = (context, tags = [], options)=>{
+    const action = 'getPostsByTags';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const { latitude, limit, longitude, type } = parsePostOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+    const formatTagNames = JSON.stringify(tags.map((tag)=>parseChar(tag, 32).toLowerCase()));
+    const sortBy = [];
+    const filters = [
+        `p.type == "${type}"`,
+        'p.privacy == "public"'
+    ];
+    const formatLatitude = parseNum(latitude);
+    const formatLongitude = parseNum(longitude);
+    if (formatLatitude && formatLongitude) {
+        selectQueries.push(`LET distance = DISTANCE(
+      ${formatLatitude},
+      ${formatLongitude},
+      NOT_NULL(p.latitude, 0),
+      NOT_NULL(p.longitude, 0))
+    `);
+        selectObjects.push('distance:distance');
+        sortBy.push('distance');
+    }
+    if (tags.length) {
+        sortBy.push('matchedTags DESC');
+        selectQueries.push(`LET matchedTags = LENGTH(
+      FOR t IN tags
+      FILTER t.matched == true
+      RETURN t
+    )`);
+        selectObjects.push('matchedTags:matchedTags');
+        filters.push('matchedTags > 0');
+    }
+    sortBy.push('p.added DESC');
+    selectObjects.push('tags:tags');
+    const aqlQry = `FOR p IN posts
+    LET tags = (
+      FOR tag, it IN 1..1 INBOUND p isTagged
+      LET matched = LENGTH(${formatTagNames}) > 0 && POSITION(${formatTagNames}, tag.name)
+      SORT tag.name
+      RETURN MERGE(tag, {matched:matched})
+    )
+    ${selectQueries.join('\n')}
+    FILTER ${filters.join(' && ')}
+    ${limit.aql}
+    SORT ${sortBy.join(', ')}
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getPostsByUser = (context, userId, options)=>{
+    const action = 'getPostsByUser';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const { limit, type } = parsePostOptions(options);
+    const formatUserId = parseId(userId);
+    const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+    const aqlQry = `FOR p IN posts
+    FILTER p.userId == "${formatUserId}" && p.type == "${type}" && p.privacy == "public" && p.parent == null
+    ${selectQueries.join('\n')}
+    ${limit.aql}
+    SORT p.added
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getPostComments = (context, postId, options)=>{
+    const action = 'getPostComments';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const { limit, type } = parsePostOptions(options);
+    const formatItemId = parseId(postId);
+    // Get the parent post to get restrictions
+    const aqlQry = aql`FOR p IN posts
+    FILTER p.type == ${type} && p._key == ${formatItemId}
+    LIMIT 1
+    RETURN p`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((post)=>{
+        const { _key, groupId, privacy = 'default' } = post;
+        // Query based on privacy level
+        let privacyAqlQry;
+        if (groupId && privacy === 'group') {
+            privacyAqlQry = `FOR p IN posts
+          FOR user IN users
+          FILTER p.parent == "${_key}" && user._key == p.userId
+          LET reactions = (
+            FOR post, r IN INBOUND p._id reactions
+            COLLECT reactionName = r.value INTO reactionItems
+            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
+          )
+          FOR group IN groups
+          FILTER group._key == p.groupId
+          FOR u, e IN OUTBOUND group._id hasConnection
+          FILTER u._key == "${sessionId}"
+          SORT p.added
+          ${limit.aql}
+          RETURN MERGE(p, {user: user, reactions: reactions})`;
+        } else if (privacy === 'public') {
+            privacyAqlQry = `FOR p IN posts
+          FOR user IN users
+          FILTER p.parent == "${_key}" && user._key == p.userId
+          LET reactions = (
+            FOR post, r IN INBOUND p._id reactions
+            COLLECT reactionName = r.value INTO reactionItems
+            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
+          )
+          SORT p.added
+          ${limit.aql}
+          RETURN MERGE(p, {user: user, reactions: reactions})`;
+        }
+        if (privacyAqlQry) {
+            return useDb(databaseName).query(privacyAqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+                logError({
+                    action,
+                    category: eventCategory,
+                    label: ErrorTypes.DATABASE_ERROR
+                }, error, context);
+                return [];
+            });
+        }
+        return [];
+    }).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const addPost = async (context, { content = '', endDate, groupId = '', location, latitude, longitude, name = '', parentId = '', privacy = 'public', tags = [], startDate, type = 'default' })=>{
+    const action = 'addPost';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const now = Date.now();
+    const postId = createHash(`post-${sessionId}`);
+    const insert = {
+        _id: `posts/${postId}`,
+        _key: postId,
+        added: now,
+        content: parseString(content, MAX_CONTENT_LENGTH) || '',
+        endDate: endDate ? parseNum(endDate, 13) : undefined,
+        groupId: groupId ? parseId(groupId) : undefined,
+        latitude: latitude !== undefined ? parseNum(latitude) : undefined,
+        location: location ? parseString(location, 160) : undefined,
+        longitude: longitude !== undefined ? parseNum(longitude) : undefined,
+        modified: now,
+        name: parseString(name, 160),
+        parentId: parentId ? parseId(parentId) : undefined,
+        privacy: parseVarChar(privacy, 16),
+        startDate: startDate ? parseNum(startDate, 13) : undefined,
+        type: parseChar(type, 32),
+        userId: sessionId
+    };
+    const aqlQry = aql`INSERT ${insert} IN posts RETURN NEW`;
+    try {
+        const savedPost = await useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                label: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+        const { _id: postDocId } = savedPost;
+        const contentTagNames = await extractTags(insert.content || '');
+        if (tags.length || contentTagNames.length) {
+            const userTags = (await getTagsByName(context, tags.map(({ name })=>name || ''))).map((tag)=>({
+                    ...tag,
+                    tagBy: sessionId
+                }));
+            const contentTags = (await getTagsByName(context, contentTagNames || [])).map((tag)=>({
+                    ...tag,
+                    tagBy: 'extract'
+                }));
+            const updatedTags = await updateTagsInItem(context, {
+                itemDocId: postDocId,
+                tags: [
+                    ...contentTags,
+                    ...userTags
+                ]
+            });
+            return {
+                ...savedPost,
+                tags: updatedTags
+            };
+        }
+        return savedPost;
+    } catch (error) {
+        throw error;
+    }
+};
+export const updatePost = async (context, post)=>{
+    const action = 'updatePost';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const now = Date.now();
+    const parsedPost = parsePost(post);
+    const { postId, tags = [] } = parsedPost;
+    const update = {
+        ...parsedPost,
+        modified: now
+    };
+    if (!postId) {
+        throw logException({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.INVALID_ID
+        }, context);
+    }
+    const insert = {
+        ...update,
+        _key: postId,
+        added: now,
+        userId: sessionId
+    };
+    const aqlQry = aql`UPSERT {_key: ${postId}, userId: ${sessionId}}
+    INSERT ${insert}
+    UPDATE ${update}
+    IN posts RETURN NEW`;
+    try {
+        const updatedPost = await useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, {}));
+        const { _id: updatedPostId } = updatedPost;
+        const contentTagNames = await extractTags(insert.content || '');
+        if (tags?.length || contentTagNames?.length) {
+            const userTags = tags?.length ? (await getTagsByName(context, tags.map(({ name })=>name || ''))).map((tag)=>({
+                    ...tag,
+                    tagBy: sessionId
+                })) : [];
+            const contentTags = contentTagNames?.length ? (await getTagsByName(context, contentTagNames || [])).map((tag)=>({
+                    ...tag,
+                    tagBy: 'extract'
+                })) : [];
+            const updatedTags = await updateTagsInItem(context, {
+                itemDocId: updatedPostId,
+                tags: [
+                    ...contentTags,
+                    ...userTags
+                ]
+            });
+            return {
+                ...updatedPost,
+                tags: updatedTags
+            };
+        }
+        return updatedPost;
+    } catch (error) {
+        throw error;
+    }
+};
+export const deletePost = async (context, postDocId)=>{
+    const action = 'deletePost';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const formatPostId = parseArangoId(postDocId);
+    if (!formatPostId) {
+        throw logException({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.INVALID_ID
+        }, context);
+    }
+    const edgeAqlQry = aql`FOR t IN isTagged
+  FILTER t._to == ${formatPostId}
+  REMOVE t IN isTagged`;
+    await useDb(databaseName).query(edgeAqlQry).catch((error)=>{
+        throw error;
+    });
+    const fileAqlQry = aql`FOR f IN hasFile
+    FILTER f._to == ${formatPostId}
+    REMOVE f IN hasFile`;
+    await useDb(databaseName).query(fileAqlQry).catch((error)=>{
+        throw error;
+    });
+    const aqlQry = aql`FOR p IN posts
+      FILTER p._id == ${formatPostId} && p.userId == ${sessionId}
+      LIMIT 1
+      REMOVE p IN posts
+      RETURN OLD`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>{
+        throw error;
+    });
+};
+export const createPostEdge = (context, postDocId, itemDocId, edgeType = 'isPosted', props = {})=>{
+    const action = 'createPostEdge';
+    const { databaseName } = context;
+    const edgeCollection = useDb(databaseName).collection(edgeType);
+    const formatPostId = parseArangoId(postDocId);
+    const formatDocId = parseArangoId(itemDocId);
+    if (!formatDocId || !formatPostId) {
+        throw new Error(ErrorTypes.INVALID_ID);
+    }
+    const edgeId = createHash(`postEdge-${formatPostId}-${formatDocId}`);
+    const edge = {
+        _from: formatPostId,
+        _key: edgeId,
+        _to: formatDocId,
+        added: Date.now(),
+        ...props
+    };
+    return edgeCollection.save(edge, {
+        returnNew: true
+    }).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/posts.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport { parseNum } from '@nlabs/utils/parsers/numbers';\nimport {\n    createHash, parseArangoId, parseChar, parseId, parseString, parseVarChar\n} from '@nlabs/utils/parsers/strings';\nimport { aql } from 'arangojs';\nimport { AqlQuery } from 'arangojs/aql';\n\nimport { parsePost } from '../adapters/postAdapter.js';\nimport { ErrorTypes } from '../types/error.types.js';\nimport { logError, logException } from '../utils/analyticsUtils.js';\nimport { getLimit, useDb } from '../utils/arangodbUtils.js';\nimport { extractTags, getTagsByName, updateTagsInItem } from './tags.js';\n\nimport type { EdgeCollection } from 'arangojs/collections';\nimport type { ArangoDbLimit } from '../types/arangodb.types.js';\nimport type { ApiContext } from '../types/auth.types.js';\nimport type { FileType } from '../types/files.types.js';\nimport type { PostInputType, PostOptions, PostType } from '../types/posts.types.js';\nimport type { TagType } from '../types/tags.types.js';\n\nconst MAX_CONTENT_LENGTH: number = 100000;\nconst eventCategory: string = 'posts';\n\nexport const parsePostOptions = (options: PostOptions = {}) => {\n  const {\n    from = 0,\n    latitude = 0,\n    longitude = 0,\n    to = 30,\n    type = 'post'\n  } = options;\n\n  return {\n    latitude: parseNum(latitude, 32),\n    limit: getLimit(from, to) as ArangoDbLimit,\n    longitude: parseNum(longitude, 32),\n    type: parseChar(type, 32)\n  };\n};\n\nexport const getPostOptional = (fields: string[] = [], sessionId: string = '') =>\n  (fields || []).reduce((selects: {objects: string[], queries: string[]}, field: string) => {\n    switch(field) {\n      case 'hasRsvp': {\n        selects.queries.push(`LET hasRsvp = TO_BOOL(FIRST(\n          FOR post, r IN INBOUND p._id hasReaction\n          FILTER r.name == \"rsvp\" && r.type == \"posts\" && r._from == \"users/${sessionId}\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        ))`);\n        selects.objects.push('hasRsvp:hasRsvp');\n        return selects;\n      }\n      case 'isSaved': {\n        selects.queries.push(`LET isSaved = TO_BOOL(FIRST(\n          FOR post, r IN INBOUND p._id hasReaction\n          FILTER r.name == \"pin\" && r.type == \"posts\" && r._from == \"users/${sessionId}\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        ))`);\n        selects.objects.push('isSaved:isSaved');\n        return selects;\n      }\n      case 'reactions': {\n        selects.queries.push(`LET reactions = (\n          FOR post, r IN INBOUND p._id hasReaction\n          COLLECT reactionName = r.value INTO reactionItems\n          RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n        )`);\n        selects.objects.push('reactions:reactions');\n        return selects;\n      }\n      case 'rsvpCount': {\n        selects.queries.push(`LET rsvpCount = FIRST(\n          FOR post, r IN INBOUND p._id hasReaction\n          FILTER r.name == \"rsvp\" && r.type == \"posts\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        )`);\n        selects.objects.push('rsvpCount:rsvpCount');\n        return selects;\n      }\n      case 'viewCount': {\n        selects.queries.push(`LET viewCount = FIRST(\n          FOR post, r IN INBOUND p._id hasReaction\n          FILTER r.name == \"view\" && r.type == \"posts\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        )`);\n        selects.objects.push('viewCount:viewCount');\n        return selects;\n      }\n      default: {\n        return selects;\n      }\n    }\n  }, {objects: [], queries: []});\n\nexport const getPost = async (\n  context: ApiContext,\n  postId: string,\n  options?: PostOptions\n): Promise<PostType> => {\n  const action: string = 'getPost';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const formatItemId: string = parseId(postId);\n  const {type} = parsePostOptions(options);\n  const database = useDb(databaseName);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const aqlQry: AqlQuery = aql`FOR p IN posts\n    FILTER p._key == ${formatItemId} && p.type == ${type}\n    LIMIT 1\n    RETURN p`;\n\n  return database.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((post: PostType) => {\n      const {\n        _id: postDocId,\n        userId,\n        groupId,\n        privacy = 'default'\n      }: PostType = post;\n\n      let privacyAqlQry: string | undefined;\n\n      if(userId === sessionId) {\n        return post;\n      }\n\n      if(groupId && privacy === 'group') {\n        privacyAqlQry = `LET p = DOCUMENT(\"${postDocId}\")\n          ${selectQueries.join('\\n')}\n          FOR group IN groups\n          FILTER group._key == p.groupId\n          FOR u, e IN OUTBOUND group._id hasConnection\n          FILTER u._key == \"${sessionId}\"\n          LIMIT 1\n          RETURN MERGE(p, {${selectObjects.join(', ')}})`;\n      } else if(privacy === 'public') {\n        privacyAqlQry = `LET p = DOCUMENT(\"${postDocId}\")\n          ${selectQueries.join('\\n')}\n          LIMIT 1\n          RETURN MERGE(p, {${selectObjects.join(', ')}})`;\n      }\n\n      if(privacyAqlQry) {\n        return database.query(privacyAqlQry)\n          .then((cursor) => cursor.next())\n          .catch((error: Error) => logError({\n            action,\n            category: eventCategory,\n            label: ErrorTypes.DATABASE_ERROR\n          }, error, context));\n      }\n\n      return {};\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\n\n// export const getPostList = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {\n//   // const action: string = 'getListByApp';\n//   const {database, fields, session: {userId: sessionId}} = context;\n//   const {limit, type} = parsePostOptions(options);\n//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n//   const aqlQry: string = `FOR p IN posts\n//     FILTER p.type == \"${type}\" && p.privacy == \"public\" && p.parent == null\n//     ${selectQueries.join('\\n')}\n//     ${limit.aql}\n//     SORT p.added\n//     RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n//   return database.query(aqlQry)\n//     .then((cursor) => cursor.all())\n//     .catch((error: Error) => {\n//       throw error;\n//     });\n// };\n\nexport const getPostsByArea = (\n  context: ApiContext,\n  latitude: number,\n  longitude: number,\n  options?: PostOptions\n): Promise<PostType[]> => {\n  const action: string = 'getPostsByArea';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const formatLatitude: number = parseNum(latitude);\n  const formatLongitude: number = parseNum(longitude);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  selectQueries.push(`LET distance = DISTANCE(\n    ${formatLatitude},\n    ${formatLongitude},\n    NOT_NULL(p.latitude, 0),\n    NOT_NULL(p.longitude, 0))\n  `);\n  selectObjects.push('distance:distance');\n\n  const aqlQry: string = `FOR p IN posts\n    ${selectQueries.join('\\n')}\n    FILTER p.type == \"${type}\" && p.privacy == \"public\" && p.parentId == null\n    ${limit.aql}\n    SORT distance, p.added\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as PostType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\n// export const getPostsByGroup = (\n//   context: ApiContext,\n//   groupId: string,\n//   options?: PostOptions\n// ): Promise<PostType[]> => {\n//   // const action: string = 'getListByGroup';\n//   const {database, fields, session: {userId: sessionId}} = context;\n//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n\n//   // Group id\n//   const formatGroupId: string = parseId(groupId);\n//   const db = database;\n//   const aqlQry: string = `FOR u, g IN INBOUND ${formatGroupId} hasGroup\n//       FILTER u._key == ${sessionId}\n//       RETURN g`;\n\n//   return db.query(aqlQry)\n//     .then((cursor) => cursor.all())\n//     .then((groups: GroupType[] = []) => {\n//       if(groups.length) {\n//         const {limit, type} = parsePostOptions(options);\n//         const postAqlQry: string = `FOR p IN posts\n//           FILTER p.type == \"${type}\" && p.groupId == \"${formatGroupId}\" && p.parent == null\n//           ${selectQueries.join('\\n')}\n//           ${limit.aql}\n//           SORT p.added\n//           RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n//         return db.query(postAqlQry)\n//           .then((cursor) => cursor.all())\n//           .catch((error: Error) => {\n//             throw error;\n//           });\n//       }\n\n//       return [];\n//     })\n//     .catch((error: Error) => {\n//       throw error;\n//     });\n// };\n\nexport const getPostsByLatest = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {\n  // const action: string = 'getListByLatest';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const aqlQry: string = `FOR p IN posts\n    FILTER p.type == \"${type}\" && p.privacy == \"public\" && p.parent == null\n    ${selectQueries.join('\\n')}\n    ${limit.aql}\n    SORT p.added DESC\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getPostsByReactions = (\n  context: ApiContext,\n  reactions: string[] = [],\n  options?: PostOptions\n): Promise<PostType[]> => {\n  const action: string = 'getPostsByReactions';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {latitude, limit, longitude, type} = parsePostOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const formatSessionId: string = `users/${sessionId}`;\n  const formatReactions: string = JSON.stringify(reactions.map((reaction) => parseChar(reaction, 32).toLowerCase()));\n  const sortBy: string[] = [];\n  const filters: string[] = [`p.type == \"${type}\"`, 'p.privacy == \"public\"'];\n  const formatLatitude: number = parseNum(latitude);\n  const formatLongitude: number = parseNum(longitude);\n\n  if(formatLatitude && formatLongitude) {\n    selectQueries.push(`LET distance = DISTANCE(\n      ${formatLatitude},\n      ${formatLongitude},\n      NOT_NULL(p.latitude, 0),\n      NOT_NULL(p.longitude, 0))\n    `);\n    selectObjects.push('distance:distance');\n    sortBy.push('distance');\n  }\n\n  if(reactions.length) {\n    sortBy.push('matchedTags DESC');\n    selectQueries.push(`LET matchedReactions = LENGTH(\n      FOR mr IN reactions\n      FILTER mr.matched == true\n      RETURN mr\n    )`);\n    selectObjects.push('matchedReactions:matchedReactions');\n    filters.push('matchedReactions > 0');\n  }\n\n  sortBy.push('p.added DESC');\n  selectObjects.push('reactions:reactions');\n\n  // Get data from database\n  const aqlQry: string = `FOR p, r IN OUTBOUND \"${formatSessionId}\" hasReaction\n    LET reactions = (\n      FOR reaction, hr IN 1..1 INBOUND p isTagged\n      LET matched = LENGTH(${formatReactions}) > 0 && POSITION(${formatReactions}, reaction.name)\n      SORT reaction.name\n      RETURN MERGE(reaction, {matched:matched})\n    )\n    ${selectQueries.join('\\n')}\n    FILTER ${filters.join(' && ')}\n    ${limit.aql}\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as PostType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\nexport const getPostsByTags = (\n  context: ApiContext,\n  tags: string[] = [],\n  options?: PostOptions\n): Promise<PostType[]> => {\n  const action: string = 'getPostsByTags';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {latitude, limit, longitude, type} = parsePostOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const formatTagNames: string = JSON.stringify(tags.map((tag) => parseChar(tag, 32).toLowerCase()));\n  const sortBy: string[] = [];\n  const filters: string[] = [`p.type == \"${type}\"`, 'p.privacy == \"public\"'];\n  const formatLatitude: number = parseNum(latitude);\n  const formatLongitude: number = parseNum(longitude);\n\n  if(formatLatitude && formatLongitude) {\n    selectQueries.push(`LET distance = DISTANCE(\n      ${formatLatitude},\n      ${formatLongitude},\n      NOT_NULL(p.latitude, 0),\n      NOT_NULL(p.longitude, 0))\n    `);\n    selectObjects.push('distance:distance');\n    sortBy.push('distance');\n  }\n\n  if(tags.length) {\n    sortBy.push('matchedTags DESC');\n    selectQueries.push(`LET matchedTags = LENGTH(\n      FOR t IN tags\n      FILTER t.matched == true\n      RETURN t\n    )`);\n    selectObjects.push('matchedTags:matchedTags');\n    filters.push('matchedTags > 0');\n  }\n\n  sortBy.push('p.added DESC');\n  selectObjects.push('tags:tags');\n\n  const aqlQry: string = `FOR p IN posts\n    LET tags = (\n      FOR tag, it IN 1..1 INBOUND p isTagged\n      LET matched = LENGTH(${formatTagNames}) > 0 && POSITION(${formatTagNames}, tag.name)\n      SORT tag.name\n      RETURN MERGE(tag, {matched:matched})\n    )\n    ${selectQueries.join('\\n')}\n    FILTER ${filters.join(' && ')}\n    ${limit.aql}\n    SORT ${sortBy.join(', ')}\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as PostType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\nexport const getPostsByUser = (context: ApiContext, userId: string, options?: PostOptions): Promise<PostType[]> => {\n  const action: string = 'getPostsByUser';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const formatUserId: string = parseId(userId);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const aqlQry: string = `FOR p IN posts\n    FILTER p.userId == \"${formatUserId}\" && p.type == \"${type}\" && p.privacy == \"public\" && p.parent == null\n    ${selectQueries.join('\\n')}\n    ${limit.aql}\n    SORT p.added\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as PostType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\nexport const getPostComments = (context: ApiContext, postId: string, options?: PostOptions): Promise<PostType[]> => {\n  const action: string = 'getPostComments';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const formatItemId: string = parseId(postId);\n\n  // Get the parent post to get restrictions\n  const aqlQry: AqlQuery = aql`FOR p IN posts\n    FILTER p.type == ${type} && p._key == ${formatItemId}\n    LIMIT 1\n    RETURN p`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((post: PostType) => {\n      const {\n        _key,\n        groupId,\n        privacy = 'default'\n      }: PostType = post;\n\n      // Query based on privacy level\n      let privacyAqlQry: string | undefined;\n\n      if(groupId && privacy === 'group') {\n        privacyAqlQry = `FOR p IN posts\n          FOR user IN users\n          FILTER p.parent == \"${_key}\" && user._key == p.userId\n          LET reactions = (\n            FOR post, r IN INBOUND p._id reactions\n            COLLECT reactionName = r.value INTO reactionItems\n            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n          )\n          FOR group IN groups\n          FILTER group._key == p.groupId\n          FOR u, e IN OUTBOUND group._id hasConnection\n          FILTER u._key == \"${sessionId}\"\n          SORT p.added\n          ${limit.aql}\n          RETURN MERGE(p, {user: user, reactions: reactions})`;\n      } else if(privacy === 'public') {\n        privacyAqlQry = `FOR p IN posts\n          FOR user IN users\n          FILTER p.parent == \"${_key}\" && user._key == p.userId\n          LET reactions = (\n            FOR post, r IN INBOUND p._id reactions\n            COLLECT reactionName = r.value INTO reactionItems\n            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n          )\n          SORT p.added\n          ${limit.aql}\n          RETURN MERGE(p, {user: user, reactions: reactions})`;\n      }\n\n      if(privacyAqlQry) {\n        return useDb(databaseName).query(privacyAqlQry)\n          .then((cursor) => cursor.all() as unknown as PostType[])\n          .catch((error: Error) => {\n            logError({\n              action,\n              category: eventCategory,\n              label: ErrorTypes.DATABASE_ERROR\n            }, error, context);\n\n            return [] as PostType[];\n          });\n      }\n\n      return [] as PostType[];\n    })\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\nexport const addPost = async (\n  context: ApiContext,\n  {\n    content = '',\n    endDate,\n    groupId = '',\n    location,\n    latitude,\n    longitude,\n    name = '',\n    parentId = '',\n    privacy = 'public',\n    tags = [],\n    startDate,\n    type = 'default'\n  }: PostInputType\n): Promise<PostType> => {\n  const action: string = 'addPost';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const now = Date.now();\n  const postId = createHash(`post-${sessionId}`);\n  const insert: PostType = {\n    _id: `posts/${postId}`,\n    _key: postId,\n    added: now,\n    content: parseString(content, MAX_CONTENT_LENGTH) || '',\n    endDate: endDate ? parseNum(endDate, 13) : undefined,\n    groupId: groupId ? parseId(groupId) : undefined,\n    latitude: latitude !== undefined ? parseNum(latitude) : undefined,\n    location: location ? parseString(location, 160) : undefined,\n    longitude: longitude !== undefined ? parseNum(longitude) : undefined,\n    modified: now,\n    name: parseString(name, 160),\n    parentId: parentId ? parseId(parentId) : undefined,\n    privacy: parseVarChar(privacy, 16),\n    startDate: startDate ? parseNum(startDate, 13) : undefined,\n    type: parseChar(type, 32),\n    userId: sessionId\n  };\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN posts RETURN NEW`;\n\n  try {\n    const savedPost: PostType = await useDb(databaseName).query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n    const {_id: postDocId} = savedPost;\n    const contentTagNames = await extractTags(insert.content || '');\n\n    if(tags.length || contentTagNames.length) {\n      const userTags = (await getTagsByName(context, tags.map(({name}) => name || '')))\n        .map((tag) => ({...tag, tagBy: sessionId}));\n      const contentTags = (await getTagsByName(context, contentTagNames || []))\n        .map((tag) => ({...tag, tagBy: 'extract'}));\n      const updatedTags: TagType[] = await updateTagsInItem(\n        context,\n        {\n          itemDocId: postDocId,\n          tags: [...contentTags, ...userTags]\n        }\n      );\n\n      return {\n        ...savedPost,\n        tags: updatedTags\n      };\n    }\n\n    return savedPost;\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const updatePost = async (context: ApiContext, post: PostInputType): Promise<PostType> => {\n  const action: string = 'updatePost';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const now: number = Date.now();\n  const parsedPost = parsePost(post);\n  const {\n    postId,\n    tags = []\n  } = parsedPost;\n\n  const update: PostType = {\n    ...parsedPost,\n    modified: now\n  };\n\n  if(!postId) {\n    throw logException({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.INVALID_ID\n    }, context);\n  }\n\n  const insert = {\n    ...update,\n    _key: postId,\n    added: now,\n    userId: sessionId\n  };\n  const aqlQry: AqlQuery = aql`UPSERT {_key: ${postId}, userId: ${sessionId}}\n    INSERT ${insert}\n    UPDATE ${update}\n    IN posts RETURN NEW`;\n\n  try {\n    const updatedPost: PostType = await useDb(databaseName)\n      .query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, {}));\n    const {_id: updatedPostId} = updatedPost;\n    const contentTagNames = await extractTags(insert.content || '');\n\n    if(tags?.length || contentTagNames?.length) {\n      const userTags = tags?.length ? (await getTagsByName(context, tags.map(({name}) => name || '')))\n        .map((tag) => ({...tag, tagBy: sessionId})) : [];\n      const contentTags = contentTagNames?.length ? (await getTagsByName(context, contentTagNames || []))\n        .map((tag) => ({...tag, tagBy: 'extract'})) : [];\n      const updatedTags: TagType[] = await updateTagsInItem(\n        context,\n        {\n          itemDocId: updatedPostId,\n          tags: [...contentTags, ...userTags]\n        }\n      );\n\n      return {\n        ...updatedPost,\n        tags: updatedTags\n      };\n    }\n\n    return updatedPost;\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const deletePost = async (context: ApiContext, postDocId: string): Promise<PostType> => {\n  const action: string = 'deletePost';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const formatPostId: string = parseArangoId(postDocId);\n\n  if(!formatPostId) {\n    throw logException({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.INVALID_ID\n    }, context);\n  }\n\n  const edgeAqlQry: AqlQuery = aql`FOR t IN isTagged\n  FILTER t._to == ${formatPostId}\n  REMOVE t IN isTagged`;\n\n  await useDb(databaseName).query(edgeAqlQry)\n    .catch((error: Error) => {\n      throw error;\n    });\n\n  const fileAqlQry: AqlQuery = aql`FOR f IN hasFile\n    FILTER f._to == ${formatPostId}\n    REMOVE f IN hasFile`;\n\n  await useDb(databaseName).query(fileAqlQry)\n    .catch((error: Error) => {\n      throw error;\n    });\n\n  const aqlQry = aql`FOR p IN posts\n      FILTER p._id == ${formatPostId} && p.userId == ${sessionId}\n      LIMIT 1\n      REMOVE p IN posts\n      RETURN OLD`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const createPostEdge = (\n  context: ApiContext,\n  postDocId: string,\n  itemDocId: string,\n  edgeType: string = 'isPosted',\n  props = {}\n): Promise<FileType> => {\n  const action = 'createPostEdge';\n  const {databaseName} = context;\n  const edgeCollection: EdgeCollection = useDb(databaseName).collection(edgeType);\n  const formatPostId: string = parseArangoId(postDocId);\n  const formatDocId: string = parseArangoId(itemDocId);\n\n  if(!formatDocId || !formatPostId) {\n    throw new Error(ErrorTypes.INVALID_ID);\n  }\n\n  const edgeId: string = createHash(`postEdge-${formatPostId}-${formatDocId}`);\n  const edge = {\n    _from: formatPostId,\n    _key: edgeId,\n    _to: formatDocId,\n    added: Date.now(),\n    ...props\n  };\n\n  return edgeCollection.save(edge, {returnNew: true})\n    .catch((error: Error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n    });\n};\n"],"names":["parseNum","createHash","parseArangoId","parseChar","parseId","parseString","parseVarChar","aql","parsePost","ErrorTypes","logError","logException","getLimit","useDb","extractTags","getTagsByName","updateTagsInItem","MAX_CONTENT_LENGTH","eventCategory","parsePostOptions","options","from","latitude","longitude","to","type","limit","getPostOptional","fields","sessionId","reduce","selects","field","queries","push","objects","getPost","context","postId","action","databaseName","session","userId","formatItemId","database","selectObjects","selectQueries","aqlQry","query","then","cursor","next","post","_id","postDocId","groupId","privacy","privacyAqlQry","join","catch","error","category","label","DATABASE_ERROR","getPostsByArea","formatLatitude","formatLongitude","all","getPostsByLatest","getPostsByReactions","reactions","formatSessionId","formatReactions","JSON","stringify","map","reaction","toLowerCase","sortBy","filters","length","getPostsByTags","tags","formatTagNames","tag","getPostsByUser","formatUserId","getPostComments","_key","addPost","content","endDate","location","name","parentId","startDate","now","Date","insert","added","undefined","modified","savedPost","contentTagNames","userTags","tagBy","contentTags","updatedTags","itemDocId","updatePost","parsedPost","update","value","INVALID_ID","updatedPost","updatedPostId","deletePost","formatPostId","edgeAqlQry","fileAqlQry","createPostEdge","edgeType","props","edgeCollection","collection","formatDocId","Error","edgeId","edge","_from","_to","save","returnNew"],"mappings":"AAAA;;;CAGC,GACD,SAASA,QAAQ,QAAQ,+BAA+B;AACxD,SACIC,UAAU,EAAEC,aAAa,EAAEC,SAAS,EAAEC,OAAO,EAAEC,WAAW,EAAEC,YAAY,QACrE,+BAA+B;AACtC,SAASC,GAAG,QAAQ,WAAW;AAG/B,SAASC,SAAS,QAAQ,6BAA6B;AACvD,SAASC,UAAU,QAAQ,0BAA0B;AACrD,SAASC,QAAQ,EAAEC,YAAY,QAAQ,6BAA6B;AACpE,SAASC,QAAQ,EAAEC,KAAK,QAAQ,4BAA4B;AAC5D,SAASC,WAAW,EAAEC,aAAa,EAAEC,gBAAgB,QAAQ,YAAY;AASzE,MAAMC,qBAA6B;AACnC,MAAMC,gBAAwB;AAE9B,OAAO,MAAMC,mBAAmB,CAACC,UAAuB,CAAC,CAAC;IACxD,MAAM,EACJC,OAAO,CAAC,EACRC,WAAW,CAAC,EACZC,YAAY,CAAC,EACbC,KAAK,EAAE,EACPC,OAAO,MAAM,EACd,GAAGL;IAEJ,OAAO;QACLE,UAAUtB,SAASsB,UAAU;QAC7BI,OAAOd,SAASS,MAAMG;QACtBD,WAAWvB,SAASuB,WAAW;QAC/BE,MAAMtB,UAAUsB,MAAM;IACxB;AACF,EAAE;AAEF,OAAO,MAAME,kBAAkB,CAACC,SAAmB,EAAE,EAAEC,YAAoB,EAAE,GAC3E,AAACD,CAAAA,UAAU,EAAE,AAAD,EAAGE,MAAM,CAAC,CAACC,SAAiDC;QACtE,OAAOA;YACL,KAAK;gBAAW;oBACdD,QAAQE,OAAO,CAACC,IAAI,CAAC,CAAC;;4EAE8C,EAAEL,UAAU;;;UAG9E,CAAC;oBACHE,QAAQI,OAAO,CAACD,IAAI,CAAC;oBACrB,OAAOH;gBACT;YACA,KAAK;gBAAW;oBACdA,QAAQE,OAAO,CAACC,IAAI,CAAC,CAAC;;2EAE6C,EAAEL,UAAU;;;UAG7E,CAAC;oBACHE,QAAQI,OAAO,CAACD,IAAI,CAAC;oBACrB,OAAOH;gBACT;YACA,KAAK;gBAAa;oBAChBA,QAAQE,OAAO,CAACC,IAAI,CAAC,CAAC;;;;SAIrB,CAAC;oBACFH,QAAQI,OAAO,CAACD,IAAI,CAAC;oBACrB,OAAOH;gBACT;YACA,KAAK;gBAAa;oBAChBA,QAAQE,OAAO,CAACC,IAAI,CAAC,CAAC;;;;;SAKrB,CAAC;oBACFH,QAAQI,OAAO,CAACD,IAAI,CAAC;oBACrB,OAAOH;gBACT;YACA,KAAK;gBAAa;oBAChBA,QAAQE,OAAO,CAACC,IAAI,CAAC,CAAC;;;;;SAKrB,CAAC;oBACFH,QAAQI,OAAO,CAACD,IAAI,CAAC;oBACrB,OAAOH;gBACT;YACA;gBAAS;oBACP,OAAOA;gBACT;QACF;IACF,GAAG;QAACI,SAAS,EAAE;QAAEF,SAAS,EAAE;IAAA,GAAG;AAEjC,OAAO,MAAMG,UAAU,OACrBC,SACAC,QACAlB;IAEA,MAAMmB,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEZ,MAAM,EAAEa,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAClE,MAAMM,eAAuBvC,QAAQkC;IACrC,MAAM,EAACb,IAAI,EAAC,GAAGN,iBAAiBC;IAChC,MAAMwB,WAAW/B,MAAM2B;IACvB,MAAM,EAACL,SAASU,aAAa,EAAEZ,SAASa,aAAa,EAAC,GAAGnB,gBAAgBC,QAAQC;IACjF,MAAMkB,SAAmBxC,GAAG,CAAC;qBACV,EAAEoC,aAAa,cAAc,EAAElB,KAAK;;YAE7C,CAAC;IAEX,OAAOmB,SAASI,KAAK,CAACD,QACnBE,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI,IAC5BF,IAAI,CAAC,CAACG;QACL,MAAM,EACJC,KAAKC,SAAS,EACdZ,MAAM,EACNa,OAAO,EACPC,UAAU,SAAS,EACpB,GAAaJ;QAEd,IAAIK;QAEJ,IAAGf,WAAWb,WAAW;YACvB,OAAOuB;QACT;QAEA,IAAGG,WAAWC,YAAY,SAAS;YACjCC,gBAAgB,CAAC,kBAAkB,EAAEH,UAAU;UAC7C,EAAER,cAAcY,IAAI,CAAC,MAAM;;;;4BAIT,EAAE7B,UAAU;;2BAEb,EAAEgB,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;QACnD,OAAO,IAAGF,YAAY,UAAU;YAC9BC,gBAAgB,CAAC,kBAAkB,EAAEH,UAAU;UAC7C,EAAER,cAAcY,IAAI,CAAC,MAAM;;2BAEV,EAAEb,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;QACnD;QAEA,IAAGD,eAAe;YAChB,OAAOb,SAASI,KAAK,CAACS,eACnBR,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI,IAC5BQ,KAAK,CAAC,CAACC,QAAiBlD,SAAS;oBAChC6B;oBACAsB,UAAU3C;oBACV4C,OAAOrD,WAAWsD,cAAc;gBAClC,GAAGH,OAAOvB;QACd;QAEA,OAAO,CAAC;IACV,GACCsB,KAAK,CAAC,CAACC,QAAiBlD,SAAS;YAChC6B;YACAsB,UAAU3C;YACV4C,OAAOrD,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;AACd,EAAE;AAGF,oGAAoG;AACpG,8CAA8C;AAC9C,sEAAsE;AACtE,qDAAqD;AACrD,iGAAiG;AACjG,2CAA2C;AAC3C,8EAA8E;AAC9E,kCAAkC;AAClC,mBAAmB;AACnB,mBAAmB;AACnB,gEAAgE;AAEhE,kCAAkC;AAClC,sCAAsC;AACtC,iCAAiC;AACjC,qBAAqB;AACrB,UAAU;AACV,KAAK;AAEL,OAAO,MAAM2B,iBAAiB,CAC5B3B,SACAf,UACAC,WACAH;IAEA,MAAMmB,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEZ,MAAM,EAAEa,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAClE,MAAM,EAACX,KAAK,EAAED,IAAI,EAAC,GAAGN,iBAAiBC;IACvC,MAAM6C,iBAAyBjE,SAASsB;IACxC,MAAM4C,kBAA0BlE,SAASuB;IACzC,MAAM,EAACY,SAASU,aAAa,EAAEZ,SAASa,aAAa,EAAC,GAAGnB,gBAAgBC,QAAQC;IACjFiB,cAAcZ,IAAI,CAAC,CAAC;IAClB,EAAE+B,eAAe;IACjB,EAAEC,gBAAgB;;;EAGpB,CAAC;IACDrB,cAAcX,IAAI,CAAC;IAEnB,MAAMa,SAAiB,CAAC;IACtB,EAAED,cAAcY,IAAI,CAAC,MAAM;sBACT,EAAEjC,KAAK;IACzB,EAAEC,MAAMnB,GAAG,CAAC;;8BAEc,EAAEsC,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;IAE1D,OAAO7C,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOiB,GAAG,IAC3BR,KAAK,CAAC,CAACC;QACNlD,SAAS;YACP6B;YACAsB,UAAU3C;YACV4C,OAAOrD,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,mCAAmC;AACnC,yBAAyB;AACzB,qBAAqB;AACrB,0BAA0B;AAC1B,8BAA8B;AAC9B,gDAAgD;AAChD,sEAAsE;AACtE,iGAAiG;AAEjG,gBAAgB;AAChB,oDAAoD;AACpD,yBAAyB;AACzB,0EAA0E;AAC1E,sCAAsC;AACtC,mBAAmB;AAEnB,4BAA4B;AAC5B,sCAAsC;AACtC,4CAA4C;AAC5C,4BAA4B;AAC5B,2DAA2D;AAC3D,qDAAqD;AACrD,8FAA8F;AAC9F,wCAAwC;AACxC,yBAAyB;AACzB,yBAAyB;AACzB,sEAAsE;AAEtE,sCAAsC;AACtC,4CAA4C;AAC5C,uCAAuC;AACvC,2BAA2B;AAC3B,gBAAgB;AAChB,UAAU;AAEV,mBAAmB;AACnB,SAAS;AACT,iCAAiC;AACjC,qBAAqB;AACrB,UAAU;AACV,KAAK;AAEL,OAAO,MAAM+B,mBAAmB,CAAC/B,SAAqBjB;IACpD,4CAA4C;IAC5C,MAAM,EAACoB,YAAY,EAAEZ,MAAM,EAAEa,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAClE,MAAM,EAACX,KAAK,EAAED,IAAI,EAAC,GAAGN,iBAAiBC;IACvC,MAAM,EAACe,SAASU,aAAa,EAAEZ,SAASa,aAAa,EAAC,GAAGnB,gBAAgBC,QAAQC;IACjF,MAAMkB,SAAiB,CAAC;sBACJ,EAAEtB,KAAK;IACzB,EAAEqB,cAAcY,IAAI,CAAC,MAAM;IAC3B,EAAEhC,MAAMnB,GAAG,CAAC;;8BAEc,EAAEsC,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;IAE1D,OAAO7C,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOiB,GAAG,IAC3BR,KAAK,CAAC,CAACC;QACN,MAAMA;IACR;AACJ,EAAE;AAEF,OAAO,MAAMS,sBAAsB,CACjChC,SACAiC,YAAsB,EAAE,EACxBlD;IAEA,MAAMmB,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEZ,MAAM,EAAEa,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAClE,MAAM,EAACf,QAAQ,EAAEI,KAAK,EAAEH,SAAS,EAAEE,IAAI,EAAC,GAAGN,iBAAiBC;IAC5D,MAAM,EAACe,SAASU,aAAa,EAAEZ,SAASa,aAAa,EAAC,GAAGnB,gBAAgBC,QAAQC;IACjF,MAAM0C,kBAA0B,CAAC,MAAM,EAAE1C,WAAW;IACpD,MAAM2C,kBAA0BC,KAAKC,SAAS,CAACJ,UAAUK,GAAG,CAAC,CAACC,WAAazE,UAAUyE,UAAU,IAAIC,WAAW;IAC9G,MAAMC,SAAmB,EAAE;IAC3B,MAAMC,UAAoB;QAAC,CAAC,WAAW,EAAEtD,KAAK,CAAC,CAAC;QAAE;KAAwB;IAC1E,MAAMwC,iBAAyBjE,SAASsB;IACxC,MAAM4C,kBAA0BlE,SAASuB;IAEzC,IAAG0C,kBAAkBC,iBAAiB;QACpCpB,cAAcZ,IAAI,CAAC,CAAC;MAClB,EAAE+B,eAAe;MACjB,EAAEC,gBAAgB;;;IAGpB,CAAC;QACDrB,cAAcX,IAAI,CAAC;QACnB4C,OAAO5C,IAAI,CAAC;IACd;IAEA,IAAGoC,UAAUU,MAAM,EAAE;QACnBF,OAAO5C,IAAI,CAAC;QACZY,cAAcZ,IAAI,CAAC,CAAC;;;;KAInB,CAAC;QACFW,cAAcX,IAAI,CAAC;QACnB6C,QAAQ7C,IAAI,CAAC;IACf;IAEA4C,OAAO5C,IAAI,CAAC;IACZW,cAAcX,IAAI,CAAC;IAEnB,yBAAyB;IACzB,MAAMa,SAAiB,CAAC,sBAAsB,EAAEwB,gBAAgB;;;2BAGvC,EAAEC,gBAAgB,kBAAkB,EAAEA,gBAAgB;;;;IAI7E,EAAE1B,cAAcY,IAAI,CAAC,MAAM;WACpB,EAAEqB,QAAQrB,IAAI,CAAC,QAAQ;IAC9B,EAAEhC,MAAMnB,GAAG,CAAC;8BACc,EAAEsC,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;IAE1D,OAAO7C,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOiB,GAAG,IAC3BR,KAAK,CAAC,CAACC;QACNlD,SAAS;YACP6B;YACAsB,UAAU3C;YACV4C,OAAOrD,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAM4C,iBAAiB,CAC5B5C,SACA6C,OAAiB,EAAE,EACnB9D;IAEA,MAAMmB,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEZ,MAAM,EAAEa,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAClE,MAAM,EAACf,QAAQ,EAAEI,KAAK,EAAEH,SAAS,EAAEE,IAAI,EAAC,GAAGN,iBAAiBC;IAC5D,MAAM,EAACe,SAASU,aAAa,EAAEZ,SAASa,aAAa,EAAC,GAAGnB,gBAAgBC,QAAQC;IACjF,MAAMsD,iBAAyBV,KAAKC,SAAS,CAACQ,KAAKP,GAAG,CAAC,CAACS,MAAQjF,UAAUiF,KAAK,IAAIP,WAAW;IAC9F,MAAMC,SAAmB,EAAE;IAC3B,MAAMC,UAAoB;QAAC,CAAC,WAAW,EAAEtD,KAAK,CAAC,CAAC;QAAE;KAAwB;IAC1E,MAAMwC,iBAAyBjE,SAASsB;IACxC,MAAM4C,kBAA0BlE,SAASuB;IAEzC,IAAG0C,kBAAkBC,iBAAiB;QACpCpB,cAAcZ,IAAI,CAAC,CAAC;MAClB,EAAE+B,eAAe;MACjB,EAAEC,gBAAgB;;;IAGpB,CAAC;QACDrB,cAAcX,IAAI,CAAC;QACnB4C,OAAO5C,IAAI,CAAC;IACd;IAEA,IAAGgD,KAAKF,MAAM,EAAE;QACdF,OAAO5C,IAAI,CAAC;QACZY,cAAcZ,IAAI,CAAC,CAAC;;;;KAInB,CAAC;QACFW,cAAcX,IAAI,CAAC;QACnB6C,QAAQ7C,IAAI,CAAC;IACf;IAEA4C,OAAO5C,IAAI,CAAC;IACZW,cAAcX,IAAI,CAAC;IAEnB,MAAMa,SAAiB,CAAC;;;2BAGC,EAAEoC,eAAe,kBAAkB,EAAEA,eAAe;;;;IAI3E,EAAErC,cAAcY,IAAI,CAAC,MAAM;WACpB,EAAEqB,QAAQrB,IAAI,CAAC,QAAQ;IAC9B,EAAEhC,MAAMnB,GAAG,CAAC;SACP,EAAEuE,OAAOpB,IAAI,CAAC,MAAM;8BACC,EAAEb,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;IAE1D,OAAO7C,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOiB,GAAG,IAC3BR,KAAK,CAAC,CAACC;QACNlD,SAAS;YACP6B;YACAsB,UAAU3C;YACV4C,OAAOrD,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAMgD,iBAAiB,CAAChD,SAAqBK,QAAgBtB;IAClE,MAAMmB,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEZ,MAAM,EAAEa,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAClE,MAAM,EAACX,KAAK,EAAED,IAAI,EAAC,GAAGN,iBAAiBC;IACvC,MAAMkE,eAAuBlF,QAAQsC;IACrC,MAAM,EAACP,SAASU,aAAa,EAAEZ,SAASa,aAAa,EAAC,GAAGnB,gBAAgBC,QAAQC;IACjF,MAAMkB,SAAiB,CAAC;wBACF,EAAEuC,aAAa,gBAAgB,EAAE7D,KAAK;IAC1D,EAAEqB,cAAcY,IAAI,CAAC,MAAM;IAC3B,EAAEhC,MAAMnB,GAAG,CAAC;;8BAEc,EAAEsC,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;IAE1D,OAAO7C,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOiB,GAAG,IAC3BR,KAAK,CAAC,CAACC;QACNlD,SAAS;YACP6B;YACAsB,UAAU3C;YACV4C,OAAOrD,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAMkD,kBAAkB,CAAClD,SAAqBC,QAAgBlB;IACnE,MAAMmB,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEC,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAC1D,MAAM,EAACX,KAAK,EAAED,IAAI,EAAC,GAAGN,iBAAiBC;IACvC,MAAMuB,eAAuBvC,QAAQkC;IAErC,0CAA0C;IAC1C,MAAMS,SAAmBxC,GAAG,CAAC;qBACV,EAAEkB,KAAK,cAAc,EAAEkB,aAAa;;YAE7C,CAAC;IAEX,OAAO9B,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI,IAC5BF,IAAI,CAAC,CAACG;QACL,MAAM,EACJoC,IAAI,EACJjC,OAAO,EACPC,UAAU,SAAS,EACpB,GAAaJ;QAEd,+BAA+B;QAC/B,IAAIK;QAEJ,IAAGF,WAAWC,YAAY,SAAS;YACjCC,gBAAgB,CAAC;;8BAEK,EAAE+B,KAAK;;;;;;;;;4BAST,EAAE3D,UAAU;;UAE9B,EAAEH,MAAMnB,GAAG,CAAC;6DACuC,CAAC;QACxD,OAAO,IAAGiD,YAAY,UAAU;YAC9BC,gBAAgB,CAAC;;8BAEK,EAAE+B,KAAK;;;;;;;UAO3B,EAAE9D,MAAMnB,GAAG,CAAC;6DACuC,CAAC;QACxD;QAEA,IAAGkD,eAAe;YAChB,OAAO5C,MAAM2B,cAAcQ,KAAK,CAACS,eAC9BR,IAAI,CAAC,CAACC,SAAWA,OAAOiB,GAAG,IAC3BR,KAAK,CAAC,CAACC;gBACNlD,SAAS;oBACP6B;oBACAsB,UAAU3C;oBACV4C,OAAOrD,WAAWsD,cAAc;gBAClC,GAAGH,OAAOvB;gBAEV,OAAO,EAAE;YACX;QACJ;QAEA,OAAO,EAAE;IACX,GACCsB,KAAK,CAAC,CAACC;QACNlD,SAAS;YACP6B;YACAsB,UAAU3C;YACV4C,OAAOrD,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAMoD,UAAU,OACrBpD,SACA,EACEqD,UAAU,EAAE,EACZC,OAAO,EACPpC,UAAU,EAAE,EACZqC,QAAQ,EACRtE,QAAQ,EACRC,SAAS,EACTsE,OAAO,EAAE,EACTC,WAAW,EAAE,EACbtC,UAAU,QAAQ,EAClB0B,OAAO,EAAE,EACTa,SAAS,EACTtE,OAAO,SAAS,EACF;IAEhB,MAAMc,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEC,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAC1D,MAAM2D,MAAMC,KAAKD,GAAG;IACpB,MAAM1D,SAASrC,WAAW,CAAC,KAAK,EAAE4B,WAAW;IAC7C,MAAMqE,SAAmB;QACvB7C,KAAK,CAAC,MAAM,EAAEf,QAAQ;QACtBkD,MAAMlD;QACN6D,OAAOH;QACPN,SAASrF,YAAYqF,SAASzE,uBAAuB;QACrD0E,SAASA,UAAU3F,SAAS2F,SAAS,MAAMS;QAC3C7C,SAASA,UAAUnD,QAAQmD,WAAW6C;QACtC9E,UAAUA,aAAa8E,YAAYpG,SAASsB,YAAY8E;QACxDR,UAAUA,WAAWvF,YAAYuF,UAAU,OAAOQ;QAClD7E,WAAWA,cAAc6E,YAAYpG,SAASuB,aAAa6E;QAC3DC,UAAUL;QACVH,MAAMxF,YAAYwF,MAAM;QACxBC,UAAUA,WAAW1F,QAAQ0F,YAAYM;QACzC5C,SAASlD,aAAakD,SAAS;QAC/BuC,WAAWA,YAAY/F,SAAS+F,WAAW,MAAMK;QACjD3E,MAAMtB,UAAUsB,MAAM;QACtBiB,QAAQb;IACV;IACA,MAAMkB,SAAmBxC,GAAG,CAAC,OAAO,EAAE2F,OAAO,oBAAoB,CAAC;IAElE,IAAI;QACF,MAAMI,YAAsB,MAAMzF,MAAM2B,cAAcQ,KAAK,CAACD,QACzDE,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI,IAC5BQ,KAAK,CAAC,CAACC,QAAiBlD,SAAS;gBAChC6B;gBACAsB,UAAU3C;gBACV4C,OAAOrD,WAAWsD,cAAc;YAClC,GAAGH,OAAOvB;QACZ,MAAM,EAACgB,KAAKC,SAAS,EAAC,GAAGgD;QACzB,MAAMC,kBAAkB,MAAMzF,YAAYoF,OAAOR,OAAO,IAAI;QAE5D,IAAGR,KAAKF,MAAM,IAAIuB,gBAAgBvB,MAAM,EAAE;YACxC,MAAMwB,WAAW,AAAC,CAAA,MAAMzF,cAAcsB,SAAS6C,KAAKP,GAAG,CAAC,CAAC,EAACkB,IAAI,EAAC,GAAKA,QAAQ,IAAG,EAC5ElB,GAAG,CAAC,CAACS,MAAS,CAAA;oBAAC,GAAGA,GAAG;oBAAEqB,OAAO5E;gBAAS,CAAA;YAC1C,MAAM6E,cAAc,AAAC,CAAA,MAAM3F,cAAcsB,SAASkE,mBAAmB,EAAE,CAAA,EACpE5B,GAAG,CAAC,CAACS,MAAS,CAAA;oBAAC,GAAGA,GAAG;oBAAEqB,OAAO;gBAAS,CAAA;YAC1C,MAAME,cAAyB,MAAM3F,iBACnCqB,SACA;gBACEuE,WAAWtD;gBACX4B,MAAM;uBAAIwB;uBAAgBF;iBAAS;YACrC;YAGF,OAAO;gBACL,GAAGF,SAAS;gBACZpB,MAAMyB;YACR;QACF;QAEA,OAAOL;IACT,EAAE,OAAM1C,OAAO;QACb,MAAMA;IACR;AACF,EAAE;AAEF,OAAO,MAAMiD,aAAa,OAAOxE,SAAqBe;IACpD,MAAMb,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEC,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAC1D,MAAM2D,MAAcC,KAAKD,GAAG;IAC5B,MAAMc,aAAatG,UAAU4C;IAC7B,MAAM,EACJd,MAAM,EACN4C,OAAO,EAAE,EACV,GAAG4B;IAEJ,MAAMC,SAAmB;QACvB,GAAGD,UAAU;QACbT,UAAUL;IACZ;IAEA,IAAG,CAAC1D,QAAQ;QACV,MAAM3B,aAAa;YACjB4B;YACAsB,UAAU3C;YACV8F,OAAOvG,WAAWwG,UAAU;QAC9B,GAAG5E;IACL;IAEA,MAAM6D,SAAS;QACb,GAAGa,MAAM;QACTvB,MAAMlD;QACN6D,OAAOH;QACPtD,QAAQb;IACV;IACA,MAAMkB,SAAmBxC,GAAG,CAAC,cAAc,EAAE+B,OAAO,UAAU,EAAET,UAAU;WACjE,EAAEqE,OAAO;WACT,EAAEa,OAAO;uBACG,CAAC;IAEtB,IAAI;QACF,MAAMG,cAAwB,MAAMrG,MAAM2B,cACvCQ,KAAK,CAACD,QACNE,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI,IAC5BQ,KAAK,CAAC,CAACC,QAAiBlD,SAAS;gBAChC6B;gBACAsB,UAAU3C;gBACV8F,OAAOvG,WAAWsD,cAAc;YAClC,GAAGH,OAAO,CAAC;QACb,MAAM,EAACP,KAAK8D,aAAa,EAAC,GAAGD;QAC7B,MAAMX,kBAAkB,MAAMzF,YAAYoF,OAAOR,OAAO,IAAI;QAE5D,IAAGR,MAAMF,UAAUuB,iBAAiBvB,QAAQ;YAC1C,MAAMwB,WAAWtB,MAAMF,SAAS,AAAC,CAAA,MAAMjE,cAAcsB,SAAS6C,KAAKP,GAAG,CAAC,CAAC,EAACkB,IAAI,EAAC,GAAKA,QAAQ,IAAG,EAC3FlB,GAAG,CAAC,CAACS,MAAS,CAAA;oBAAC,GAAGA,GAAG;oBAAEqB,OAAO5E;gBAAS,CAAA,KAAM,EAAE;YAClD,MAAM6E,cAAcH,iBAAiBvB,SAAS,AAAC,CAAA,MAAMjE,cAAcsB,SAASkE,mBAAmB,EAAE,CAAA,EAC9F5B,GAAG,CAAC,CAACS,MAAS,CAAA;oBAAC,GAAGA,GAAG;oBAAEqB,OAAO;gBAAS,CAAA,KAAM,EAAE;YAClD,MAAME,cAAyB,MAAM3F,iBACnCqB,SACA;gBACEuE,WAAWO;gBACXjC,MAAM;uBAAIwB;uBAAgBF;iBAAS;YACrC;YAGF,OAAO;gBACL,GAAGU,WAAW;gBACdhC,MAAMyB;YACR;QACF;QAEA,OAAOO;IACT,EAAE,OAAMtD,OAAO;QACb,MAAMA;IACR;AACF,EAAE;AAEF,OAAO,MAAMwD,aAAa,OAAO/E,SAAqBiB;IACpD,MAAMf,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEC,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAC1D,MAAMgF,eAAuBnH,cAAcoD;IAE3C,IAAG,CAAC+D,cAAc;QAChB,MAAM1G,aAAa;YACjB4B;YACAsB,UAAU3C;YACV8F,OAAOvG,WAAWwG,UAAU;QAC9B,GAAG5E;IACL;IAEA,MAAMiF,aAAuB/G,GAAG,CAAC;kBACjB,EAAE8G,aAAa;sBACX,CAAC;IAErB,MAAMxG,MAAM2B,cAAcQ,KAAK,CAACsE,YAC7B3D,KAAK,CAAC,CAACC;QACN,MAAMA;IACR;IAEF,MAAM2D,aAAuBhH,GAAG,CAAC;oBACf,EAAE8G,aAAa;uBACZ,CAAC;IAEtB,MAAMxG,MAAM2B,cAAcQ,KAAK,CAACuE,YAC7B5D,KAAK,CAAC,CAACC;QACN,MAAMA;IACR;IAEF,MAAMb,SAASxC,GAAG,CAAC;sBACC,EAAE8G,aAAa,gBAAgB,EAAExF,UAAU;;;gBAGjD,CAAC;IAEf,OAAOhB,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI,IAC5BQ,KAAK,CAAC,CAACC;QACN,MAAMA;IACR;AACJ,EAAE;AAEF,OAAO,MAAM4D,iBAAiB,CAC5BnF,SACAiB,WACAsD,WACAa,WAAmB,UAAU,EAC7BC,QAAQ,CAAC,CAAC;IAEV,MAAMnF,SAAS;IACf,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAMsF,iBAAiC9G,MAAM2B,cAAcoF,UAAU,CAACH;IACtE,MAAMJ,eAAuBnH,cAAcoD;IAC3C,MAAMuE,cAAsB3H,cAAc0G;IAE1C,IAAG,CAACiB,eAAe,CAACR,cAAc;QAChC,MAAM,IAAIS,MAAMrH,WAAWwG,UAAU;IACvC;IAEA,MAAMc,SAAiB9H,WAAW,CAAC,SAAS,EAAEoH,aAAa,CAAC,EAAEQ,aAAa;IAC3E,MAAMG,OAAO;QACXC,OAAOZ;QACP7B,MAAMuC;QACNG,KAAKL;QACL1B,OAAOF,KAAKD,GAAG;QACf,GAAG0B,KAAK;IACV;IAEA,OAAOC,eAAeQ,IAAI,CAACH,MAAM;QAACI,WAAW;IAAI,GAC9CzE,KAAK,CAAC,CAACC;QACN,MAAMlD,SAAS;YACb6B;YACAsB,UAAU3C;YACV8F,OAAOvG,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;IACZ;AACJ,EAAE"}