refactoring

dashboard/server/api/admin/metrics.ts

@@ -0,0 +1,36 @@
+import { ProjectModel } from "@schema/project/ProjectSchema";
+import { UserModel } from "@schema/UserSchema";
+import { EventModel } from "@schema/metrics/EventSchema";
+import { VisitModel } from "@schema/metrics/VisitSchema";
+
+export default defineEventHandler(async event => {
+    const userData = getRequestUser(event);
+    if (!userData?.logged) return;
+    if (!userData.user.roles.includes('ADMIN')) return;
+
+    const { filterFrom, filterTo } = getQuery(event);
+
+
+    const matchQuery = {
+        created_at: {
+            $gte: new Date(filterFrom as string),
+            $lte: new Date(filterTo as string)
+        }
+    }
+
+    const totalProjects = await ProjectModel.countDocuments({ ...matchQuery });
+    const premiumProjects = await ProjectModel.countDocuments({ ...matchQuery, premium: true });
+
+    const deadProjects = await ProjectModel.countDocuments({ ...matchQuery });
+
+    const totalUsers = await UserModel.countDocuments({ ...matchQuery });
+
+    const totalVisits = 0;
+
+    const totalEvents = await EventModel.countDocuments({ ...matchQuery });
+
+
+    return { totalProjects, premiumProjects, deadProjects, totalUsers, totalVisits, totalEvents }
+
+
+});

dashboard/server/api/ai/[chat_id]/delete.ts

@@ -3,7 +3,7 @@ import { AiChatModel } from "@schema/ai/AiChatSchema";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestDataOld(event);
+    const data = await getRequestData(event, [], ['AI']);
     if (!data) return;
 
     const { project_id } = data;

dashboard/server/api/ai/[chat_id]/get_messages.ts

@@ -4,7 +4,7 @@ import type OpenAI from "openai";
 import { getChartsInMessage } from "~/server/services/AiService";
 
 export default defineEventHandler(async event => {
-    const data = await getRequestDataOld(event);
+    const data = await getRequestData(event, [], ['AI']);
     if (!data) return;
 
     const isAdmin = data.user.user.roles.includes('ADMIN');

dashboard/server/api/ai/[chat_id]/status.ts

@@ -2,7 +2,7 @@
 import { AiChatModel } from "@schema/ai/AiChatSchema";
 
 export default defineEventHandler(async event => {
-    const data = await getRequestDataOld(event);
+    const data = await getRequestData(event, [], ['AI']);
     if (!data) return;
 
     const { project_id } = data;

dashboard/server/api/ai/chats_remaining.ts

@@ -10,7 +10,7 @@ export async function getAiChatRemainings(project_id: string) {
 }
 
 export default defineEventHandler(async event => {
-    const data = await getRequestDataOld(event);
+    const data = await getRequestData(event, [], ['AI']);
     if (!data) return;
 
     const { pid } = data;

dashboard/server/api/ai/delete_all_chats.ts

@@ -3,7 +3,7 @@ import { AiChatModel } from "@schema/ai/AiChatSchema";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestDataOld(event);
+    const data = await getRequestData(event, [], ['AI']);
     if (!data) return;
 
     const { project_id } = data;

dashboard/server/api/ai/send_message.post.ts

@@ -5,7 +5,7 @@ import { ProjectLimitModel } from "@schema/project/ProjectsLimits";
 
 
 export default defineEventHandler(async event => {
-    const data = await getRequestDataOld(event);
+    const data = await getRequestData(event, [], ['AI']);
     if (!data) return;
 
     const { pid } = data;

dashboard/server/api/data/browsers.ts

@@ -4,7 +4,7 @@ import { Redis } from "~/server/services/CacheService";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['GUEST', 'RANGE', 'GUEST', 'DOMAIN']);
+    const data = await getRequestData(event, ['RANGE', 'DOMAIN'], ['WEB']);
     if (!data) return;
 
     const { pid, from, to, project_id, limit, domain } = data;

dashboard/server/api/data/count.ts

@@ -4,7 +4,7 @@ import { Redis } from "~/server/services/CacheService";
 export default defineEventHandler(async event => {
 
 
-    const data = await getRequestData(event, ['GUEST', 'DOMAIN', 'RANGE', 'SCHEMA']);
+    const data = await getRequestData(event, ['DOMAIN', 'RANGE', 'SCHEMA'], ['WEB']);
     if (!data) return;
 
     const { schemaName, pid, from, to, model, project_id, domain } = data;

dashboard/server/api/data/countries.ts

@@ -4,7 +4,7 @@ import { Redis } from "~/server/services/CacheService";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['GUEST', 'RANGE', 'GUEST', 'DOMAIN']);
+    const data = await getRequestData(event, ['RANGE', 'DOMAIN'], ['WEB']);
     if (!data) return;
 
     const { pid, from, to, project_id, limit, domain } = data;

dashboard/server/api/data/devices.ts

@@ -4,7 +4,7 @@ import { Redis } from "~/server/services/CacheService";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['GUEST', 'RANGE', 'GUEST', 'DOMAIN']);
+    const data = await getRequestData(event, ['RANGE', 'DOMAIN'], ['WEB']);
     if (!data) return;
 
     const { pid, from, to, project_id, limit, domain } = data;

dashboard/server/api/data/events.ts

@@ -4,7 +4,7 @@ import { Redis } from "~/server/services/CacheService";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['GUEST', 'DOMAIN', 'RANGE']);
+    const data = await getRequestData(event, ['DOMAIN', 'RANGE'], ['EVENTS']);
     if (!data) return;
 
     const { pid, from, to, project_id, limit, domain } = data;

dashboard/server/api/data/oss.ts

@@ -4,7 +4,7 @@ import { Redis } from "~/server/services/CacheService";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['GUEST', 'RANGE', 'GUEST', 'DOMAIN']);
+    const data = await getRequestData(event, ['RANGE', 'DOMAIN'], ['WEB']);
     if (!data) return;
 
     const { pid, from, to, project_id, limit, domain } = data;

dashboard/server/api/data/pages.ts

@@ -4,7 +4,7 @@ import { Redis } from "~/server/services/CacheService";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['GUEST', 'RANGE', 'GUEST', 'DOMAIN']);
+    const data = await getRequestData(event, ['RANGE', 'DOMAIN'], ['WEB']);
     if (!data) return;
 
     const { pid, from, to, project_id, limit, domain } = data;

dashboard/server/api/data/referrers.ts

@@ -4,7 +4,7 @@ import { Redis } from "~/server/services/CacheService";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['OFFSET', 'RANGE', 'GUEST', 'DOMAIN']);
+    const data = await getRequestData(event, ['OFFSET', 'RANGE', 'DOMAIN'], ['WEB']);
     if (!data) return;
 
     const { pid, from, to, project_id, limit, domain } = data;

dashboard/server/api/domains/list.ts

@@ -1,18 +1,45 @@
 
 import { VisitModel } from "@schema/metrics/VisitSchema";
+import { TeamMemberModel } from "~/shared/schema/TeamMemberSchema";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['GUEST']);
+    const data = await getRequestData(event, []);
     if (!data) return;
 
-    const { project_id } = data;
+    const { project_id, project, user } = data;
 
-    const result = await VisitModel.aggregate([
+    const result: { _id: string, visits: number }[] = await VisitModel.aggregate([
         { $match: { project_id, } },
         { $group: { _id: "$website", visits: { $sum: 1 } } },
     ]);
 
-    return result as { _id: string, visits: number }[];
+    const isOwner = user.id === project.owner.toString();
+    if (isOwner) return [
+        {
+            _id: 'All domains',
+            visits: result.reduce((a, e) => a + e.visits, 0)
+        },
+        ...result
+    ]
+
+    const member = await TeamMemberModel.findOne({ project_id, user_id: data.user.id, pending: false });
+    if (!member) return setResponseStatus(event, 400, 'Not a member');
+    if (!member.permission) return setResponseStatus(event, 400, 'No permission');
+
+    if (member.permission.domains.includes('All domains')) {
+        return [
+            {
+                _id: 'All domains',
+                visits: result.reduce((a, e) => a + e.visits, 0)
+            },
+            ...result
+        ]
+    }
+
+    return result.filter(e => {
+        return member.permission.domains.includes(e._id);
+    });
+
 
 });

dashboard/server/api/project/links/list.ts

@@ -0,0 +1,18 @@
+
+import { UserModel } from "@schema/UserSchema";
+import { ProjectLinkModel } from "~/shared/schema/project/ProjectLinkSchema";
+
+export default defineEventHandler(async event => {
+
+    const data = await getRequestData(event, [], ['OWNER']);
+    if (!data) return;
+
+    const { project_id, project } = data;
+
+    const owner = await UserModel.findById(project.owner);
+    if (!owner) return setResponseStatus(event, 400, 'No owner');
+
+    const links = await ProjectLinkModel.find({ project_id });
+    return links;
+
+});

dashboard/server/api/project/members/accept.post.ts

@@ -0,0 +1,21 @@
+import { TeamMemberModel } from "~/shared/schema/TeamMemberSchema";
+
+export default defineEventHandler(async event => {
+
+    const data = await getRequestData(event, [], []);
+    if (!data) return [];
+
+    const body = await readBody(event);
+
+    const { project_id } = body;
+    if (!project_id) return setResponseStatus(event, 400, 'project_id is required');
+
+    const member = await TeamMemberModel.findOne({ project_id, user_id: data.user.id });
+    if (!member) return setResponseStatus(event, 400, 'member not found');
+
+    member.pending = false;
+    await member.save();
+
+    return { ok: true };
+
+});

dashboard/server/api/project/members/add.post.ts

@@ -1,28 +1,72 @@
 
 import { TeamMemberModel } from "@schema/TeamMemberSchema";
 import { UserModel } from "@schema/UserSchema";
+import { EmailServiceHelper } from "~/server/services/EmailServiceHelper";
+import { EmailService } from "~/shared/services/EmailService";
 
 export default defineEventHandler(async event => {
 
-
-    const data = await getRequestDataOld(event, { requireSchema: false, allowGuests: false, allowLitlyx: false });
+    const data = await getRequestData(event, [], ['OWNER']);
     if (!data) return;
 
-    const { project_id } = data;
+    const { project_id, project } = data;
 
     const { email } = await readBody(event);
 
     const targetUser = await UserModel.findOne({ email });
-    if (!targetUser) return setResponseStatus(event, 400, 'No user with this email');
 
 
-    await TeamMemberModel.create({
-        project_id,
-        user_id: targetUser.id,
-        pending: true,
-        role: 'GUEST'
-    });
+    const link = `http://127.0.0.1:3000/accept_invite?project_id=${project_id.toString()}`;
+
+    if (!targetUser) {
+
+        const exist = await TeamMemberModel.exists({ project_id, email });
+        if (exist) return setResponseStatus(event, 400, 'Member already invited');
+
+        await TeamMemberModel.create({
+            project_id,
+            email,
+            pending: true,
+            role: 'GUEST'
+        });
+
+        setImmediate(() => {
+            const emailData = EmailService.getEmailServerInfo('invite_project_noaccount', {
+                target: email,
+                projectName: project.name,
+                link
+            });
+            EmailServiceHelper.sendEmail(emailData);
+        });
+
+        return { ok: true };
+
+    } else {
+
+        const exist = await TeamMemberModel.exists({ project_id, user_id: targetUser.id });
+        if (exist) return setResponseStatus(event, 400, 'Member already invited');
+
+        await TeamMemberModel.create({
+            project_id,
+            user_id: targetUser.id,
+            pending: true,
+            role: 'GUEST'
+        });
+
+        setImmediate(() => {
+            const emailData = EmailService.getEmailServerInfo('invite_project', {
+
+                target: email,
+                projectName: project.name,
+                link
+            });
+            EmailServiceHelper.sendEmail(emailData);
+        });
+
+        return { ok: true };
+
+    }
+
 
-    return { ok: true };
 
 });

dashboard/server/api/project/members/decline.post.ts

@@ -0,0 +1,18 @@
+import { TeamMemberModel } from "~/shared/schema/TeamMemberSchema";
+
+export default defineEventHandler(async event => {
+
+    const data = await getRequestData(event, [], []);
+    if (!data) return [];
+
+    const body = await readBody(event);
+
+    const { project_id } = body;
+    if (!project_id) return setResponseStatus(event, 400, 'project_id is required');
+
+    const member = await TeamMemberModel.deleteOne({ project_id, user_id: data.user.id });
+    if (!member) return setResponseStatus(event, 400, 'member not found');
+
+    return { ok: true };
+
+});

dashboard/server/api/project/members/edit.post.ts

@@ -0,0 +1,25 @@
+import { TeamMemberModel } from "~/shared/schema/TeamMemberSchema";
+
+export default defineEventHandler(async event => {
+
+    const data = await getRequestData(event, [], ['OWNER']);
+    if (!data) return [];
+
+    const body = await readBody(event);
+
+    const { member_id, webAnalytics, events, ai, domains } = body;
+
+    if (!member_id) return setResponseStatus(event, 400, 'permission_id is required');
+
+    const edited = await TeamMemberModel.updateOne({ _id: member_id }, {
+        permission: {
+            webAnalytics,
+            events,
+            ai,
+            domains
+        }
+    });
+
+    return { ok: edited.modifiedCount == 1 }
+
+});

dashboard/server/api/project/members/get.ts

@@ -0,0 +1,23 @@
+
+import { TeamMemberModel, TPermission, TTeamMember } from "@schema/TeamMemberSchema";
+
+export default defineEventHandler(async event => {
+    const data = await getRequestData(event, []);
+    if (!data) return;
+    const { member_id } = getQuery(event);
+    const member = await TeamMemberModel.findById(member_id);
+    if (!member) return setResponseStatus(event, 400, 'Cannot get member');
+
+    const resultPermission: TPermission = {
+        ai: false,
+        domains: [],
+        events: false,
+        webAnalytics: false
+    }
+
+    return {
+        permission: resultPermission,
+        ...member.toJSON() as any
+    } as TTeamMember
+
+});

dashboard/server/api/project/members/kick.post.ts

@@ -5,7 +5,7 @@ import { UserModel } from "@schema/UserSchema";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestDataOld(event, { requireSchema: false, allowGuests: false, allowLitlyx: false });
+    const data = await getRequestData(event, [], ['OWNER']);
     if (!data) return;
 
     const { project_id } = data;

dashboard/server/api/project/members/leave.ts

@@ -4,7 +4,7 @@ import { TeamMemberModel } from "@schema/TeamMemberSchema";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestDataOld(event, { requireSchema: false, allowGuests: false, allowLitlyx: false });
+    const data = await getRequestData(event, []);
     if (!data) return;
 
     const { project_id, user } = data;

dashboard/server/api/project/members/list.ts

@@ -1,11 +1,20 @@
 import { ProjectModel } from "@schema/project/ProjectSchema";
-import { TeamMemberModel } from "@schema/TeamMemberSchema";
+import { TeamMemberModel, TeamMemberRole, TPermission, TTeamMember } from "@schema/TeamMemberSchema";
 import { UserModel } from "@schema/UserSchema";
 
+export type MemberWithPermissions = {
+    id: string | null,
+    email: string,
+    name: string,
+    role: TeamMemberRole,
+    pending: boolean,
+    me: boolean,
+    permission: TPermission
+}
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestDataOld(event, { requireSchema: false });
+    const data = await getRequestData(event);
     if (!data) return;
 
     const { project_id, project, user } = data;
@@ -15,25 +24,42 @@ export default defineEventHandler(async event => {
 
     const members = await TeamMemberModel.find({ project_id });
 
-    const result: { email: string, name: string, role: string, pending: boolean, me: boolean }[] = [];
+    const result: MemberWithPermissions[] = [];
 
     result.push({
+        id: null,
         email: owner.email,
         name: owner.name,
         role: 'OWNER',
         pending: false,
-        me: user.id === owner.id
+        me: user.id === owner.id,
+        permission: {
+            webAnalytics: true,
+            events: true,
+            ai: true,
+            domains: ['All domains']
+        }
     })
 
     for (const member of members) {
         const userMember = await UserModel.findById(member.user_id);
         if (!userMember) continue;
+
+        const permission: TPermission = {
+            webAnalytics: member.permission?.webAnalytics || false,
+            events: member.permission?.events || false,
+            ai: member.permission?.ai || false,
+            domains: member.permission?.domains || []
+        }
+
         result.push({
+            id: member.id,
             email: userMember.email,
             name: userMember.name,
             role: member.role,
             pending: member.pending,
-            me: user.id === userMember.id
+            me: user.id === userMember.id,
+            permission
         })
     }
 

dashboard/server/api/project/members/me.ts

@@ -0,0 +1,39 @@
+import { ProjectModel } from "@schema/project/ProjectSchema";
+import { TeamMemberModel, TeamMemberRole, TPermission, TTeamMember } from "@schema/TeamMemberSchema";
+import { UserModel } from "@schema/UserSchema";
+
+
+export default defineEventHandler(async event => {
+
+    const data = await getRequestData(event, []);
+    if (!data) return;
+
+    const { project_id, project, user } = data;
+
+    const owner = await UserModel.findById(project.owner, { _id: 1 });
+
+    if (owner && owner._id.toString() === user.id) return {
+        ai: true,
+        domains: ['All domains'],
+        events: true,
+        webAnalytics: true
+    }
+
+    const member = await TeamMemberModel.findOne({ project_id, user_id: user.id });
+
+    if (!member) return {
+        ai: true,
+        domains: ['All domains'],
+        events: true,
+        webAnalytics: true
+    }
+
+    return {
+        ai: false,
+        domains: [],
+        events: false,
+        webAnalytics: false,
+        ...(member.permission as any),
+    } as TPermission
+
+});

dashboard/server/api/project/members/pending.ts

@@ -0,0 +1,44 @@
+
+import { TeamMemberModel } from "@schema/TeamMemberSchema";
+import { Types } from "mongoose";
+
+
+export default defineEventHandler(async event => {
+
+    const data = await getRequestData(event);
+    if (!data) return;
+
+    const members = await TeamMemberModel.aggregate([
+        {
+            $match:
+            {
+                $or: [
+                    { user_id: new Types.ObjectId(data.user.id) },
+                    { email: data.user.user.email }
+                ],
+                pending: true
+            }
+        },
+        {
+            $lookup: {
+                from: 'projects',
+                as: 'project',
+                foreignField: '_id',
+                localField: 'project_id',
+            }
+        },
+        {
+            $addFields: {
+                project_name: { $arrayElemAt: ["$project.name", 0] }
+            }
+        },
+        {
+            $project: {
+                project: 0
+            }
+        }
+    ]);
+    
+    return members;
+
+});

dashboard/server/api/timeline/bouncing_rate.ts

@@ -9,16 +9,16 @@ import { checkSliceValidity } from "~/server/services/TimelineService";
 export default defineEventHandler(async event => {
 
 
-    const data = await getRequestDataOld(event, { requireSchema: false, requireSlice: true });
+    const data = await getRequestData(event, ['SLICE', 'RANGE', 'DOMAIN'], ['WEB']);
     if (!data) return;
 
-    const { pid, from, to, slice, project_id } = data;
+    const { pid, from, to, slice, project_id, domain } = data;
 
 
     const cacheKey = `timeline:bouncing_rate:${pid}:${slice}:${from}:${to}`;
     const cacheExp = 60 * 60; //1 hour
 
-    return await Redis.useCacheV2(cacheKey, cacheExp, async (noStore, updateExp) => {
+    return await Redis.useCacheV2(cacheKey, cacheExp, async () => {
 
         const [sliceValid, errorOrDays] = checkSliceValidity(from, to, slice);
         if (!sliceValid) throw Error(errorOrDays);
@@ -36,7 +36,8 @@ export default defineEventHandler(async event => {
                         created_at: {
                             $gte: DateService.startOfSlice(date, slice),
                             $lte: DateService.endOfSlice(date, slice)
-                        }
+                        },
+                        website: domain
                     },
                 },
                 { $group: { _id: "$session", count: { $sum: 1, } } },

dashboard/server/api/timeline/events.ts

@@ -4,7 +4,7 @@ import { executeTimelineAggregation } from "~/server/services/TimelineService";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['SLICE', 'GUEST', 'DOMAIN', 'RANGE', 'OFFSET']);
+    const data = await getRequestData(event, ['SLICE', 'DOMAIN', 'RANGE', 'OFFSET'], ['EVENTS']);
     if (!data) return;
 
     const { pid, from, to, slice, project_id, timeOffset, domain } = data;

dashboard/server/api/timeline/events_stacked.ts

@@ -4,7 +4,7 @@ import { executeAdvancedTimelineAggregation } from "~/server/services/TimelineSe
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['GUEST', 'RANGE', 'SLICE', 'DOMAIN']);
+    const data = await getRequestData(event, ['RANGE', 'SLICE', 'DOMAIN'], ['EVENTS']);
     if (!data) return;
 
     const { from, to, slice, project_id, timeOffset, domain } = data;

dashboard/server/api/timeline/sessions.ts

@@ -4,7 +4,7 @@ import { executeTimelineAggregation } from "~/server/services/TimelineService";
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['SLICE', 'GUEST', 'DOMAIN', 'RANGE', 'OFFSET']);
+    const data = await getRequestData(event, ['SLICE', 'DOMAIN', 'RANGE', 'OFFSET'], ['WEB']);
     if (!data) return;
 
     const { pid, from, to, slice, project_id, timeOffset, domain } = data;

dashboard/server/api/timeline/sessions_duration.ts

@@ -4,10 +4,10 @@ import { executeAdvancedTimelineAggregation, fillAndMergeTimelineAggregationV2 }
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['SLICE', 'GUEST', 'DOMAIN', 'RANGE']);
+    const data = await getRequestData(event, ['SLICE', 'DOMAIN', 'RANGE'], ['WEB']);
     if (!data) return;
 
-    const { pid, from, to, slice, project_id, timeOffset, domain } = data;
+    const { pid, from, to, slice, project_id, domain } = data;
 
     const cacheKey = `timeline:sessions_duration:${pid}:${slice}:${from}:${to}:${domain}`;
     const cacheExp = 60;

dashboard/server/api/timeline/visits.ts

@@ -4,7 +4,7 @@ import { executeAdvancedTimelineAggregation } from "~/server/services/TimelineSe
 
 export default defineEventHandler(async event => {
 
-    const data = await getRequestData(event, ['SLICE', 'GUEST', 'DOMAIN', 'RANGE', 'OFFSET']);
+    const data = await getRequestData(event, ['SLICE', 'DOMAIN', 'RANGE', 'OFFSET'], ['WEB']);
     if (!data) return;
 
     const { pid, from, to, slice, project_id, timeOffset, domain } = data;

dashboard/server/utils/getRequestData.ts

@@ -3,7 +3,7 @@ import type { EventHandlerRequest, H3Event } from 'h3'
 import { allowedModels, TModelName } from "../services/DataService";
 import { ProjectModel, TProject } from "@schema/project/ProjectSchema";
 import { Model, Types } from "mongoose";
-import { TeamMemberModel } from "@schema/TeamMemberSchema";
+import { TeamMemberModel, TPermission } from "@schema/TeamMemberSchema";
 import { Slice } from "@services/DateService";
 import { ADMIN_EMAILS } from "~/shared/data/ADMINS";
 
@@ -32,7 +32,22 @@ export type GetRequestDataOptions = {
     /** @default false */ requireOffset?: boolean,
 }
 
-export type RequestDataScope = 'GUEST' | 'SCHEMA' | 'ANON' | 'SLICE' | 'RANGE' | 'OFFSET' | 'DOMAIN';
+export type RequestDataScope = 'SCHEMA' | 'ANON' | 'SLICE' | 'RANGE' | 'OFFSET' | 'DOMAIN';
+export type RequestDataPermissions = 'WEB' | 'EVENTS' | 'AI' | 'OWNER';
+
+async function getAccessPermission(user_id: string, project: TProject): Promise<TPermission> {
+    if (!project) return { ai: false, domains: [], events: false, webAnalytics: false }
+
+    //TODO: Create table with admins
+    if (user_id === '66520c90f381ec1e9284938b') return { ai: true, domains: ['All domains'], events: true, webAnalytics: true }
+
+    const owner = project.owner.toString();
+    const project_id = project._id;
+    if (owner === user_id) return { ai: true, domains: ['All domains'], events: true, webAnalytics: true }
+    const member = await TeamMemberModel.findOne({ project_id, user_id }, { permission: 1 });
+    if (!member) return { ai: false, domains: [], events: false, webAnalytics: false }
+    return { ai: false, domains: [], events: false, webAnalytics: false, ...member.permission as any }
+}
 
 async function hasAccessToProject(user_id: string, project: TProject) {
     if (!project) return [false, 'NONE'];
@@ -48,10 +63,9 @@ async function hasAccessToProject(user_id: string, project: TProject) {
     return [false, 'NONE'];
 }
 
-export async function getRequestData(event: H3Event<EventHandlerRequest>, required_scopes: RequestDataScope[] = []) {
+export async function getRequestData(event: H3Event<EventHandlerRequest>, required_scopes: RequestDataScope[] = [], required_permissions: RequestDataPermissions[] = []) {
 
     const requireSchema = required_scopes.includes('SCHEMA');
-    const allowGuests = required_scopes.includes('GUEST');
     const allowAnon = required_scopes.includes('ANON');
     const requireSlice = required_scopes.includes('SLICE');
     const requireRange = required_scopes.includes('RANGE');
@@ -61,7 +75,10 @@ export async function getRequestData(event: H3Event<EventHandlerRequest>, requir
     const pid = getHeader(event, 'x-pid');
     if (!pid) return setResponseStatus(event, 400, 'x-pid is required');
 
-    let domain: any = getHeader(event, 'x-domain');
+    const originalDomain = getHeader(event, 'x-domain')?.toString();
+
+    let domain: any = originalDomain;
+
     if (requireDomain) {
         if (domain == null || domain == undefined || domain.length == 0) return setResponseStatus(event, 400, 'x-domain is required');
     }
@@ -108,16 +125,40 @@ export async function getRequestData(event: H3Event<EventHandlerRequest>, requir
     const project = await ProjectModel.findById(project_id);
     if (!project) return setResponseStatus(event, 400, 'project not found');
 
-    if (!allowAnon) {
-        const [hasAccess, role] = await hasAccessToProject(user.id, project);
-        if (!hasAccess) return setResponseStatus(event, 400, 'no access to project');
-        if (role === 'GUEST' && !allowGuests) return setResponseStatus(event, 403, 'only owner can access this');
+
+    if (user.id != project.owner.toString()) {
+        if (required_permissions.includes('OWNER')) return setResponseStatus(event, 403, 'ADMIN permission required');
+        const hasAccess = await TeamMemberModel.findOne({ project_id, user_id: user.id });
+        if (!hasAccess) return setResponseStatus(event, 403, 'No permissions');
+    }
+
+
+    if (required_permissions.length > 0 || requireDomain) {
+
+        const permission = await getAccessPermission(user.id, project);
+
+        if (required_permissions.includes('WEB') && permission.webAnalytics === false) {
+            return setResponseStatus(event, 403, 'WEB permission required');
+        }
+        if (required_permissions.includes('EVENTS') && permission.events === false) {
+            return setResponseStatus(event, 403, 'EVENTS permission required');
+        }
+        if (required_permissions.includes('AI') && permission.ai === false) {
+            return setResponseStatus(event, 403, 'AI permission required');
+        }
+        if (requireDomain && originalDomain) {
+            if (!permission.domains.includes('All domains') && !permission.domains.includes(originalDomain)) {
+                return setResponseStatus(event, 403, 'DOMAIN permission required');
+            }
+        }
+
     }
 
     return {
         from: from as string,
         to: to as string,
         domain: domain as string,
+        originalDomain: originalDomain as string,
         pid, project_id, project, user, limit, slice, schemaName, model, timeOffset: offset
     }
 }