Social Network Analysis

async def get_friend_recommendations(conn, user_id: str, limit: int = 10):
    page, _ = await conn.query("""
        MATCH (me:User {id: $user_id})-[:FOLLOWS]->(mutual:User)<-[:FOLLOWS]-(candidate:User)
        WHERE NOT EXISTS((me)-[:FOLLOWS]->(candidate)) AND candidate <> me
        WITH candidate, count(DISTINCT mutual) AS mutual_count,
             collect(DISTINCT mutual.username) AS mutual_friends
        RETURN candidate.id, candidate.username, candidate.name,
               mutual_count, mutual_friends
        ORDER BY mutual_count DESC
        LIMIT $limit
    """, {"user_id": user_id, "limit": limit})

    return [
        {
            "id": row["candidate.id"].as_string,
            "username": row["candidate.username"].as_string,
            "mutual_count": row["mutual_count"].as_int,
            "mutual_friends": row["mutual_friends"].as_array
        }
        for row in page.rows
    ]

async fn get_friend_recommendations(conn: &mut Connection, user_id: &str) -> Result<Vec<Recommendation>> {
    let params = [("user_id", Value::string(user_id))].into();
    let (page, _) = conn.query_with_params(r#"
        MATCH (me:User {id: $user_id})-[:FOLLOWS]->(mutual:User)<-[:FOLLOWS]-(candidate:User)
        WHERE NOT EXISTS((me)-[:FOLLOWS]->(candidate)) AND candidate <> me
        WITH candidate, count(DISTINCT mutual) AS mutual_count
        RETURN candidate.id, candidate.username, candidate.name, mutual_count
        ORDER BY mutual_count DESC
        LIMIT 10
    "#, &params).await?;

    let recommendations = page.rows.iter().map(|row| Recommendation {
        id: row.get("candidate.id").unwrap().as_string().unwrap(),
        username: row.get("candidate.username").unwrap().as_string().unwrap(),
        mutual_count: row.get("mutual_count").unwrap().as_int().unwrap() as i32,
    }).collect();

    Ok(recommendations)
}

async function getFriendRecommendations(userId: string, limit = 10) {
    const rows = await client.queryAll(`
        MATCH (me:User {id: $userId})-[:FOLLOWS]->(mutual:User)<-[:FOLLOWS]-(candidate:User)
        WHERE NOT EXISTS((me)-[:FOLLOWS]->(candidate)) AND candidate <> me
        WITH candidate, count(DISTINCT mutual) AS mutualCount,
             collect(DISTINCT mutual.username) AS mutualFriends
        RETURN candidate.id, candidate.username, candidate.name,
               mutualCount, mutualFriends
        ORDER BY mutualCount DESC
        LIMIT $limit
    `, { params: { userId, limit } });

    return rows.map(row => ({
        id: row.get('candidate.id')?.asString,
        username: row.get('candidate.username')?.asString,
        mutualCount: row.get('mutualCount')?.asNumber,
        mutualFriends: row.get('mutualFriends')?.asArray?.map(v => v.asString)
    }));
}

fn getFriendRecommendations(client: *GeodeClient, allocator: std.mem.Allocator, user_id: []const u8) ![]Recommendation {
    // Build params JSON object
    var params = std.json.ObjectMap.init(allocator);
    defer params.deinit();
    try params.put("user_id", .{ .string = user_id });

    const query =
        \\MATCH (me:User {id: $user_id})-[:FOLLOWS]->(mutual:User)<-[:FOLLOWS]-(candidate:User)
        \\WHERE NOT EXISTS((me)-[:FOLLOWS]->(candidate)) AND candidate <> me
        \\WITH candidate, count(DISTINCT mutual) AS mutual_count
        \\RETURN candidate.id, candidate.username, mutual_count
        \\ORDER BY mutual_count DESC LIMIT 10
    ;

    try client.sendRunGql(1, query, .{ .object = params });
    const schema = try client.receiveMessage(30000);
    allocator.free(schema);

    try client.sendPull(1, 1000);
    const result = try client.receiveMessage(30000);
    defer allocator.free(result);
    return parseRecommendations(allocator, result);
}

async def poll_notifications(user_id):
    last_seen = None
    async with client.connection() as conn:
        while True:
            page, _ = await conn.query("""
                MATCH (u:User {id: $user_id})<-[r]-()
                WHERE $last_seen IS NULL OR r.timestamp > $last_seen
                RETURN type(r) AS rel_type, r.timestamp AS ts
                ORDER BY ts DESC LIMIT 20
            """, {"user_id": user_id, "last_seen": last_seen})

            for row in page.rows:
                rel_type = row["rel_type"].raw_value
                if rel_type == "LIKED":
                    print("Someone liked your post!")
                elif rel_type == "FOLLOWED":
                    print("New follower!")
                elif rel_type == "COMMENTED":
                    print("New comment!")

            if page.rows:
                last_seen = page.rows[0]["ts"].raw_value
            await asyncio.sleep(2)

async fn poll_notifications(conn: &mut Connection, user_id: &str) -> Result<()> {
    let mut last_seen: Option<i64> = None;

    loop {
        let params = [
            ("user_id", Value::string(user_id)),
            ("last_seen", last_seen.map(Value::int).unwrap_or(Value::null())),
        ].into();

        let (page, _) = conn.query_with_params(r#"
            MATCH (u:User {id: $user_id})<-[r]-()
            WHERE $last_seen IS NULL OR r.timestamp > $last_seen
            RETURN type(r) AS rel_type, r.timestamp AS ts
            ORDER BY ts DESC LIMIT 20
        "#, &params).await?;

        for row in &page.rows {
            let rel_type = row.get("rel_type").unwrap().as_string()?;
            match rel_type.as_str() {
                "LIKED" => println!("Someone liked your post!"),
                "FOLLOWED" => println!("New follower!"),
                "COMMENTED" => println!("New comment!"),
                _ => {}
            }
            if let Some(ts) = row.get("ts").and_then(|v| v.as_int().ok()) {
                last_seen = Some(ts.max(last_seen.unwrap_or(0)));
            }
        }
        tokio::time::sleep(Duration::from_secs(2)).await;
    }
}

async function pollNotifications(userId: string) {
    let lastSeen: number | null = null;

    while (true) {
        const rows = await client.queryAll(`
            MATCH (u:User {id: $userId})<-[r]-()
            WHERE $lastSeen IS NULL OR r.timestamp > $lastSeen
            RETURN type(r) AS relType, r.timestamp AS ts
            ORDER BY ts DESC LIMIT 20
        `, { params: { userId, lastSeen } });

        for (const row of rows) {
            const relType = row.get('relType')?.asString;
            switch (relType) {
                case 'LIKED': console.log('Someone liked your post!'); break;
                case 'FOLLOWED': console.log('New follower!'); break;
                case 'COMMENTED': console.log('New comment!'); break;
            }
            const ts = row.get('ts')?.asNumber;
            if (ts && (!lastSeen || ts > lastSeen)) lastSeen = ts;
        }

        await new Promise(r => setTimeout(r, 2000));
    }
}

fn pollNotifications(client: *GeodeClient, allocator: std.mem.Allocator, user_id: []const u8) !void {
    var last_seen: ?i64 = null;
    var request_id: u64 = 1;

    while (true) {
        var params = std.json.ObjectMap.init(allocator);
        defer params.deinit();
        try params.put("user_id", .{ .string = user_id });
        try params.put("last_seen", if (last_seen) |ts| .{ .integer = ts } else .null);

        const query =
            \\MATCH (u:User {id: $user_id})<-[r]-()
            \\WHERE $last_seen IS NULL OR r.timestamp > $last_seen
            \\RETURN type(r) AS rel_type, r.timestamp AS ts
            \\ORDER BY ts DESC LIMIT 20
        ;

        try client.sendRunGql(request_id, query, .{ .object = params });
        request_id += 1;
        const schema = try client.receiveMessage(30000);
        allocator.free(schema);

        try client.sendPull(request_id - 1, 1000);
        const result = try client.receiveMessage(30000);
        defer allocator.free(result);
        // Parse JSON and handle notifications

        std.time.sleep(2 * std.time.ns_per_s);
    }
}

async def poll_live_feed(user_id):
    last_seen = None
    async with client.connection() as conn:
        while True:
            page, _ = await conn.query("""
                MATCH (me:User {id: $user_id})-[:FOLLOWS]->(friend:User)-[:POSTED]->(p:Post)
                WHERE $last_seen IS NULL OR p.created_at > $last_seen
                RETURN friend.username AS username, p.content AS content, p.created_at
                ORDER BY p.created_at DESC LIMIT 50
            """, {"user_id": user_id, "last_seen": last_seen})

            for row in page.rows:
                print(f"New post from {row['username'].raw_value}: {row['content'].raw_value}")

            if page.rows:
                last_seen = page.rows[0]["p.created_at"].raw_value
            await asyncio.sleep(3)

async fn poll_live_feed(conn: &mut Connection, user_id: &str) -> Result<()> {
    let mut last_seen: Option<i64> = None;

    loop {
        let params = [
            ("user_id", Value::string(user_id)),
            ("last_seen", last_seen.map(Value::int).unwrap_or(Value::null())),
        ].into();

        let (page, _) = conn.query_with_params(r#"
            MATCH (me:User {id: $user_id})-[:FOLLOWS]->(friend:User)-[:POSTED]->(p:Post)
            WHERE $last_seen IS NULL OR p.created_at > $last_seen
            RETURN friend.username AS username, p.content AS content, p.created_at
            ORDER BY p.created_at DESC LIMIT 50
        "#, &params).await?;

        for row in &page.rows {
            println!("New post from {}: {}",
                row.get("username").unwrap().as_string()?,
                row.get("content").unwrap().as_string()?);
        }
        tokio::time::sleep(Duration::from_secs(3)).await;
    }
}

async function pollLiveFeed(userId: string) {
    let lastSeen: number | null = null;

    while (true) {
        const rows = await client.queryAll(`
            MATCH (me:User {id: $userId})-[:FOLLOWS]->(friend:User)-[:POSTED]->(p:Post)
            WHERE $lastSeen IS NULL OR p.created_at > $lastSeen
            RETURN friend.username AS username, p.content AS content, p.created_at AS createdAt
            ORDER BY createdAt DESC LIMIT 50
        `, { params: { userId, lastSeen } });

        for (const row of rows) {
            console.log(`New post from ${row.get('username')?.asString}: ${row.get('content')?.asString}`);
            const ts = row.get('createdAt')?.asNumber;
            if (ts && (!lastSeen || ts > lastSeen)) lastSeen = ts;
        }
        await new Promise(r => setTimeout(r, 3000));
    }
}

fn pollLiveFeed(client: *GeodeClient, allocator: std.mem.Allocator, user_id: []const u8) !void {
    var last_seen: ?i64 = null;
    var request_id: u64 = 1;

    while (true) {
        var params = std.json.ObjectMap.init(allocator);
        defer params.deinit();
        try params.put("user_id", .{ .string = user_id });
        try params.put("last_seen", if (last_seen) |ts| .{ .integer = ts } else .null);

        const query =
            \\MATCH (me:User {id: $user_id})-[:FOLLOWS]->(friend:User)-[:POSTED]->(p:Post)
            \\WHERE $last_seen IS NULL OR p.created_at > $last_seen
            \\RETURN friend.username AS username, p.content AS content, p.created_at
            \\ORDER BY p.created_at DESC LIMIT 50
        ;

        try client.sendRunGql(request_id, query, .{ .object = params });
        request_id += 1;
        const schema = try client.receiveMessage(30000);
        allocator.free(schema);

        try client.sendPull(request_id - 1, 1000);
        const result = try client.receiveMessage(30000);
        defer allocator.free(result);
        // Process feed items and update last_seen

        std.time.sleep(3 * std.time.ns_per_s);
    }
}