Merge remote-tracking branch 'origin/dev' into dev

src/components/common/TypeIcon.tsx

@@ -13,7 +13,7 @@ export function TypeIcon({
     <>
       <img
         src={`${process.env.basePath || ''}/images/${type}/${
-          value.replaceAll(' ', '-').toLowerCase() || 'unknown'
+          value?.replaceAll(' ', '-').toLowerCase() || 'unknown'
         }.png`}
         alt={value}
         width={type === 'country' ? undefined : 16}

src/queries/analytics/events/getEventDataProperties.ts

@@ -24,15 +24,15 @@ async function relationalQuery(
   return rawQuery(
     `
     select
-      we.event_name as "eventName",
+      website_event.event_name as "eventName",
-      ed.data_key as "propertyName",
+      event_data.data_key as "propertyName",
       count(*) as "total"
-    from event_data ed
+    from event_data 
-    join website_event we on we.event_id = ed.website_event_id
+    join website_event on website_event.event_id = event_data.website_event_id
-    where ed.website_id = {{websiteId::uuid}}
+    where event_data.website_id = {{websiteId::uuid}}
-      and ed.created_at between {{startDate}} and {{endDate}}
+      and event_data.created_at between {{startDate}} and {{endDate}}
     ${filterQuery}
-    group by we.event_name, ed.data_key
+    group by website_event.event_name, event_data.data_key
     order by 3 desc
     limit 500
     `,

src/queries/analytics/events/getEventDataValues.ts

@@ -19,21 +19,26 @@ async function relationalQuery(
   websiteId: string,
   filters: QueryFilters & { eventName?: string; propertyName?: string },
 ) {
-  const { rawQuery, parseFilters } = prisma;
+  const { rawQuery, parseFilters, getDateSQL } = prisma;
   const { filterQuery, params } = await parseFilters(websiteId, filters);
 
   return rawQuery(
     `
     select
-      string_value as "value",
+      case 
+        when data_type = 2 then replace(string_value, '.0000', '') 
+        when data_type = 4 then ${getDateSQL('date_value', 'hour')} 
+        else string_value
+      end as "value",
       count(*) as "total"
     from event_data
-    where website_id = {{websiteId::uuid}}
+    join website_event on website_event.event_id = event_data.website_event_id
-      and created_at between {{startDate}} and {{endDate}}
+    where event_data.website_id = {{websiteId::uuid}}
-      and data_key = {{propertyName}}
+      and event_data.created_at between {{startDate}} and {{endDate}}
-      and event_key = {{eventName}}
+      and event_data.data_key = {{propertyName}}
+      and website_event.event_name = {{eventName}}
     ${filterQuery}
-    group by string_value
+    group by value
     order by 2 desc
     limit 100
     `,

src/queries/analytics/events/getWebsiteEvents.ts

@@ -44,8 +44,8 @@ async function relationalQuery(websiteId: string, filters: QueryFilters, pagePar
     ${filterQuery}
     ${
       query
-        ? `and (event_name ${like} {{query}}
+        ? `and ((event_name ${like} {{query}} and event_type = 2)
-           or url_path ${like} {{query}})`
+           or (url_path ${like} {{query}} and event_type = 1))`
         : ''
     }
     order by created_at desc
@@ -84,8 +84,8 @@ async function clickhouseQuery(websiteId: string, filters: QueryFilters, pagePar
     ${filterQuery}
     ${
       query
-        ? `and (positionCaseInsensitive(event_name, {query:String}) > 0
+        ? `and ((positionCaseInsensitive(event_name, {query:String}) > 0 and event_type = 2)
-           or positionCaseInsensitive(url_path, {query:String}) > 0)`
+           or (positionCaseInsensitive(url_path, {query:String}) > 0 and event_type = 1))`
         : ''
     }
     order by created_at desc

src/queries/analytics/getRealtimeActivity.ts

@@ -17,22 +17,22 @@ async function relationalQuery(websiteId: string, filters: QueryFilters) {
   return rawQuery(
     `
     select
-        website_event.session_id as sessionId,
+        website_event.session_id as "sessionId",
-        website_event.event_name as eventName,
+        website_event.event_name as "eventName",
-        website_event.created_at as createdAt,
+        website_event.created_at as "createdAt",
         session.browser,
         session.os,
         session.device,
         session.country,
-        session.url_path as urlPath,
+        website_event.url_path as "urlPath",
-        session.referrer_domain as referrerDomain
+        website_event.referrer_domain as "referrerDomain"
     from website_event
     inner join session
       on session.session_id = website_event.session_id
-    where website_id = {{websiteId::uuid}}
+    where website_event.website_id = {{websiteId::uuid}}
     ${filterQuery}
     ${dateQuery}
-    order by created_at asc
+    order by website_event.created_at asc
     limit 100
     `,
     params,

src/queries/analytics/getRealtimeData.ts

@@ -67,8 +67,8 @@ export async function getRealtimeData(websiteId: string, criteria: { startDate:
       visitors: sessions,
     },
     totals: {
-      views: pageviews.reduce((sum: number, { y }: { y: number }) => sum + y, 0),
+      views: pageviews.reduce((sum: number, { y }: { y: number }) => Number(sum) + Number(y), 0),
-      visitors: sessions.reduce((sum: number, { y }: { y: number }) => sum + y, 0),
+      visitors: sessions.reduce((sum: number, { y }: { y: number }) => Number(sum) + Number(y), 0),
       events: activity.filter(e => e.eventName).length,
       countries: Object.keys(countries).length,
     },

src/queries/analytics/sessions/getSessionActivity.ts

@@ -19,7 +19,7 @@ async function relationalQuery(
 ) {
   return prisma.client.websiteEvent.findMany({
     where: {
-      id: sessionId,
+      sessionId,
       websiteId,
       createdAt: { gte: startDate, lte: endDate },
     },

src/queries/analytics/sessions/getSessionData.ts

@@ -10,12 +10,26 @@ export async function getSessionData(...args: [websiteId: string, sessionId: str
 }
 
 async function relationalQuery(websiteId: string, sessionId: string) {
-  return prisma.client.sessionData.findMany({
+  const { rawQuery } = prisma;
-    where: {
+
-      id: sessionId,
+  return rawQuery(
-      websiteId,
+    `
-    },
+    select
-  });
+        website_id as "websiteId",
+        session_id as "sessionId",
+        data_key as "dataKey",
+        data_type as "dataType",
+        replace(string_value, '.0000', '') as "stringValue",
+        number_value as "numberValue",
+        date_value as "dateValue",
+        created_at as "createdAt"
+    from session_data
+    where website_id = {{websiteId::uuid}}
+      and session_id = {{sessionId::uuid}}
+    order by data_key asc
+    `,
+    { websiteId, sessionId },
+  );
 }
 
 async function clickhouseQuery(websiteId: string, sessionId: string) {
@@ -28,7 +42,7 @@ async function clickhouseQuery(websiteId: string, sessionId: string) {
         session_id as sessionId,
         data_key as dataKey,
         data_type as dataType,
-        string_value as stringValue,
+        replace(string_value, '.0000', '')  as stringValue,
         number_value as numberValue,
         date_value as dateValue,
         created_at as createdAt

src/queries/analytics/sessions/getSessionDataValues.ts

@@ -16,20 +16,24 @@ async function relationalQuery(
   websiteId: string,
   filters: QueryFilters & { propertyName?: string },
 ) {
-  const { rawQuery, parseFilters } = prisma;
+  const { rawQuery, parseFilters, getDateSQL } = prisma;
   const { filterQuery, params } = await parseFilters(websiteId, filters);
 
   return rawQuery(
     `
     select
-      string_value as "value",
+      case 
+        when data_type = 2 then replace(string_value, '.0000', '') 
+        when data_type = 4 then ${getDateSQL('date_value', 'hour')} 
+        else string_value
+      end as "value",
       count(*) as "total"
     from session_data
     where website_id = {{websiteId::uuid}}
       and created_at between {{startDate}} and {{endDate}}
       and data_key = {{propertyName}}
     ${filterQuery}
-    group by string_value
+    group by value
     order by 2 desc
     limit 100
     `,

src/queries/analytics/sessions/getWebsiteSession.ts

@@ -10,12 +10,53 @@ export async function getWebsiteSession(...args: [websiteId: string, sessionId:
 }
 
 async function relationalQuery(websiteId: string, sessionId: string) {
-  return prisma.client.session.findUnique({
+  const { rawQuery, getTimestampDiffSQL } = prisma;
-    where: {
+
-      id: sessionId,
+  return rawQuery(
-      websiteId,
+    `
-    },
+    select id,
-  });
+      website_id as "websiteId",
+      hostname,
+      browser,
+      os,
+      device,
+      screen,
+      language,
+      country,
+      subdivision1,
+      city,
+      min(min_time) as "firstAt",
+      max(max_time) as "lastAt",
+      count(distinct visit_id) as visits,
+      sum(views) as views,
+      sum(events) as events,
+      sum(${getTimestampDiffSQL('min_time', 'max_time')}) as "totaltime" 
+    from (select
+          session.session_id as id,
+          website_event.visit_id,
+          session.website_id,
+          session.hostname,
+          session.browser,
+          session.os,
+          session.device,
+          session.screen,
+          session.language,
+          session.country,
+          session.subdivision1,
+          session.city,
+          min(website_event.created_at) as min_time,
+          max(website_event.created_at) as max_time,
+          sum(case when website_event.event_type = 1 then 1 else 0 end) as views,
+          sum(case when website_event.event_type = 1 then 1 else 0 end) as events
+    from session
+    join website_event on website_event.session_id = session.session_id
+    where session.website_id = {{websiteId::uuid}}
+      and session.session_id = {{sessionId::uuid}}
+    group by session.session_id, visit_id, session.website_id, session.hostname, session.browser, session.os, session.device, session.screen, session.language, session.country, session.subdivision1, session.city) t
+    group by id, website_id, hostname, browser, os, device, screen, language, country, subdivision1, city;
+    `,
+    { websiteId, sessionId },
+  ).then(result => result?.[0]);
 }
 
 async function clickhouseQuery(websiteId: string, sessionId: string) {

src/queries/analytics/sessions/getWebsiteSessions.ts

@@ -22,29 +22,39 @@ async function relationalQuery(websiteId: string, filters: QueryFilters, pagePar
     `
     with sessions as (
     select
-      s.session_id as "id",
+      session.session_id as "id",
-      s.website_id as "websiteId",
+      session.website_id as "websiteId",
-      hostname,
+      session.hostname,
-      browser,
+      session.browser,
-      os,
+      session.os,
-      device,
+      session.device,
-      screen,
+      session.screen,
-      language,
+      session.language,
-      country,
+      session.country,
-      subdivision1,
+      session.subdivision1,
-      city,
+      session.city,
-      min(we.created_at) as "firstAt",
+      min(website_event.created_at) as "firstAt",
-      max(we.created_at) as "lastAt",
+      max(website_event.created_at) as "lastAt",
-      count(distinct we.visit_id) as "visits",
+      count(distinct website_event.visit_id) as "visits",
-      sum(case when we.event_type = 1 then 1 else 0 end) as "views",
+      sum(case when website_event.event_type = 1 then 1 else 0 end) as "views",
-      max(we.created_at) as "createdAt"
+      max(website_event.created_at) as "createdAt"
-    from website_event we
+    from website_event 
-    join session s on s.session_id = we.session_id
+    join session on session.session_id = website_event.session_id
-    where we.website_id = {{websiteId::uuid}}
+    where website_event.website_id = {{websiteId::uuid}}
-        and we.created_at between {{startDate}} and {{endDate}}
+        and website_event.created_at between {{startDate}} and {{endDate}}
     ${filterQuery}
-    group by s.session_id, s.website_id, s.hostname, s.browser, s.os, s.device, s.screen, s.language, s.country, s.subdivision1, s.city
+    group by session.session_id, 
-    order by max(we.created_at) desc
+      session.website_id, 
+      session.hostname, 
+      session.browser, 
+      session.os, 
+      session.device, 
+      session.screen, 
+      session.language, 
+      session.country, 
+      session.subdivision1, 
+      session.city
+    order by max(website_event.created_at) desc
     limit 1000)
     select * from sessions
     `,