commit c2d5f5a644af2018b918ee651a606e816ae542d5 · nekomimi.pet/simplelink

+15 -4

frontend/src/api/client.ts

···

       63
       63
        
       };

     

       64
       64
        
       

     

       65
       65
        
       export const getLinkClickStats = async (id: number) => {

     

       66
       66
       -
       	const response = await api.get<ClickStats[]>(`/links/${id}/clicks`);

     

       67
       67
       -
       	return response.data;

     

       66
       66
       +
       	try {

     

       67
       67
       +
       		const response = await api.get<ClickStats[]>(`/links/${id}/clicks`);

     

       68
       68
       +
       		return response.data;

     

       69
       69
       +
       	} catch (error) {

     

       70
       70
       +
       		console.error('Error fetching click stats:', error);

     

       71
       71
       +
       		throw error;

     

       72
       72
       +
       	}

     

       68
       73
        
       };

     

       69
       74
        
       

     

       70
       75
        
       export const getLinkSourceStats = async (id: number) => {

     

       71
       71
       -
       	const response = await api.get<SourceStats[]>(`/links/${id}/sources`);

     

       72
       72
       -
       	return response.data;

     

       76
       76
       +
       	try {

     

       77
       77
       +
       		const response = await api.get<SourceStats[]>(`/links/${id}/sources`);

     

       78
       78
       +
       		return response.data;

     

       79
       79
       +
       	} catch (error) {

     

       80
       80
       +
       		console.error('Error fetching source stats:', error);

     

       81
       81
       +
       		throw error;

     

       82
       82
       +
       	}

     

       73
       83
        
       };

     

       84
       84
       +
       

     

       74
       85
        
       

     

       75
       86
        
       export const checkFirstUser = async () => {

     

       76
       87
        
       	const response = await api.get<{ isFirstUser: boolean }>('/auth/check-first-user');

+8 -2

frontend/src/components/StatisticsModal.tsx

···

       9
       9
        
           ResponsiveContainer,

     

       10
       10
        
       } from "recharts";

     

       11
       11
        
       import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";

     

       12
       12
       +
       import { toast } from "@/hooks/use-toast"

     

       12
       13
        
       import { useState, useEffect } from "react";

     

       13
       14
        
       

     

       14
       15
        
       import { getLinkClickStats, getLinkSourceStats } from '../api/client';

     
···

       36
       37
        
                           ]);

     

       37
       38
        
                           setClicksOverTime(clicksData);

     

       38
       39
        
                           setSourcesData(sourcesData);

     

       39
       39
       -
                       } catch (error) {

     

       40
       40
       +
                       } catch (error: any) {

     

       40
       41
        
                           console.error("Failed to fetch statistics:", error);

     

       42
       42
       +
                           toast({

     

       43
       43
       +
                               variant: "destructive",

     

       44
       44
       +
                               title: "Error",

     

       45
       45
       +
                               description: error.response?.data || "Failed to load statistics",

     

       46
       46
       +
                           });

     

       41
       47
        
                       } finally {

     

       42
       48
        
                           setLoading(false);

     

       43
       49
        
                       }

     

       44
       50
        
                   };

     

       45
       45
       -
       

     

       51
       51
       +
           

     

       46
       52
        
                   fetchData();

     

       47
       53
        
               }

     

       48
       54
        
           }, [isOpen, linkId]);

+23 -33

src/handlers.rs

···

       537
       537
        
       ) -> Result<impl Responder, AppError> {

     

       538
       538
        
           let link_id = path.into_inner();

     

       539
       539
        
       

     

       540
       540
       -
           // Verify the link belongs to the user

     

       540
       540
       +
           // First verify the link belongs to the user

     

       541
       541
        
           let link = match &state.db {

     

       542
       542
        
               DatabasePool::Postgres(pool) => {

     

       543
       543
       -
                   let mut tx = pool.begin().await?;

     

       544
       544
       -
                   let link = sqlx::query_as::<Postgres, (i32,)>(

     

       545
       545
       -
                       "SELECT id FROM links WHERE id = $1 AND user_id = $2",

     

       546
       546
       -
                   )

     

       547
       547
       -
                   .bind(link_id)

     

       548
       548
       -
                   .bind(user.user_id)

     

       549
       549
       -
                   .fetch_optional(&mut *tx)

     

       550
       550
       -
                   .await?;

     

       551
       551
       -
                   tx.commit().await?;

     

       552
       552
       -
                   link

     

       543
       543
       +
                   sqlx::query_as::<_, (i32,)>("SELECT id FROM links WHERE id = $1 AND user_id = $2")

     

       544
       544
       +
                       .bind(link_id)

     

       545
       545
       +
                       .bind(user.user_id)

     

       546
       546
       +
                       .fetch_optional(pool)

     

       547
       547
       +
                       .await?

     

       553
       548
        
               }

     

       554
       549
        
               DatabasePool::Sqlite(pool) => {

     

       555
       555
       -
                   let mut tx = pool.begin().await?;

     

       556
       556
       -
                   let link = sqlx::query_as::<Sqlite, (i32,)>(

     

       557
       557
       -
                       "SELECT id FROM links WHERE id = ? AND user_id = ?",

     

       558
       558
       -
                   )

     

       559
       559
       -
                   .bind(link_id)

     

       560
       560
       -
                   .bind(user.user_id)

     

       561
       561
       -
                   .fetch_optional(&mut *tx)

     

       562
       562
       -
                   .await?;

     

       563
       563
       -
                   tx.commit().await?;

     

       564
       564
       -
                   link

     

       550
       550
       +
                   sqlx::query_as::<_, (i32,)>("SELECT id FROM links WHERE id = ? AND user_id = ?")

     

       551
       551
       +
                       .bind(link_id)

     

       552
       552
       +
                       .bind(user.user_id)

     

       553
       553
       +
                       .fetch_optional(pool)

     

       554
       554
       +
                       .await?

     

       565
       555
        
               }

     

       566
       556
        
           };

     

       567
       557
        
       

     
···

       571
       561
        
       

     

       572
       562
        
           let clicks = match &state.db {

     

       573
       563
        
               DatabasePool::Postgres(pool) => {

     

       574
       574
       -
                   sqlx::query_as::<Postgres, ClickStats>(

     

       564
       564
       +
                   sqlx::query_as::<_, ClickStats>(

     

       575
       565
        
                       r#"

     

       576
       566
        
                       SELECT 

     

       577
       577
       -
                           DATE(created_at)::date as "date!",

     

       578
       578
       -
                           COUNT(*)::bigint as "clicks!"

     

       567
       567
       +
                           DATE(created_at) as date,

     

       568
       568
       +
                           COUNT(*) as clicks

     

       579
       569
        
                       FROM clicks

     

       580
       570
        
                       WHERE link_id = $1

     

       581
       571
        
                       GROUP BY DATE(created_at)

     
···

       588
       578
        
                   .await?

     

       589
       579
        
               }

     

       590
       580
        
               DatabasePool::Sqlite(pool) => {

     

       591
       591
       -
                   sqlx::query_as::<Sqlite, ClickStats>(

     

       581
       581
       +
                   sqlx::query_as::<_, ClickStats>(

     

       592
       582
        
                       r#"

     

       593
       583
        
                       SELECT 

     

       594
       594
       -
                           DATE(created_at) as "date!",

     

       595
       595
       -
                           COUNT(*) as "clicks!"

     

       584
       584
       +
                           DATE(created_at) as date,

     

       585
       585
       +
                           COUNT(*) as clicks

     

       596
       586
        
                       FROM clicks

     

       597
       587
        
                       WHERE link_id = ?

     

       598
       588
        
                       GROUP BY DATE(created_at)

     
···

       650
       640
        
       

     

       651
       641
        
           let sources = match &state.db {

     

       652
       642
        
               DatabasePool::Postgres(pool) => {

     

       653
       653
       -
                   sqlx::query_as::<Postgres, SourceStats>(

     

       643
       643
       +
                   sqlx::query_as::<_, SourceStats>(

     

       654
       644
        
                       r#"

     

       655
       645
        
                       SELECT 

     

       656
       656
       -
                           query_source as "source!",

     

       657
       657
       -
                           COUNT(*)::bigint as "count!"

     

       646
       646
       +
                           query_source as source,  // Remove the ! mark

     

       647
       647
       +
                           COUNT(*)::bigint as count  // Remove the ! mark

     

       658
       648
        
                       FROM clicks

     

       659
       649
        
                       WHERE link_id = $1

     

       660
       650
        
                           AND query_source IS NOT NULL

     
···

       669
       659
        
                   .await?

     

       670
       660
        
               }

     

       671
       661
        
               DatabasePool::Sqlite(pool) => {

     

       672
       672
       -
                   sqlx::query_as::<Sqlite, SourceStats>(

     

       662
       662
       +
                   sqlx::query_as::<_, SourceStats>(

     

       673
       663
        
                       r#"

     

       674
       664
        
                       SELECT 

     

       675
       675
       -
                           query_source as "source!",

     

       676
       676
       -
                           COUNT(*) as "count!"

     

       665
       665
       +
                           query_source as source,

     

       666
       666
       +
                           COUNT(*) as count

     

       677
       667
        
                       FROM clicks

     

       678
       668
        
                       WHERE link_id = ?

     

       679
       669
        
                           AND query_source IS NOT NULL

+1 -2

src/models.rs

···

       1
       1
        
       use anyhow::Result;

     

       2
       2
       -
       use chrono::NaiveDate;

     

       3
       2
        
       use futures::future::BoxFuture;

     

       4
       3
        
       use serde::{Deserialize, Serialize};

     

       5
       4
        
       use sqlx::postgres::PgRow;

     
···

       145
       144
        
       

     

       146
       145
        
       #[derive(sqlx::FromRow, Serialize)]

     

       147
       146
        
       pub struct ClickStats {

     

       148
       148
       -
           pub date: NaiveDate,

     

       147
       147
       +
           pub date: String,

     

       149
       148
        
           pub clicks: i64,

     

       150
       149
        
       }

     

       151
       150