patch of display artist's top listeners · round #0 · pull #5 · rocksky.app/rocksky

+30

apps/api/lexicons/artist/defs.json

···

       73
       73
        
                 "minimum": 0

     

       74
       74
        
               }

     

       75
       75
        
             }

     

       76
       76
       +
           },

     

       77
       77
       +
           "listenerViewBasic": {

     

       78
       78
       +
             "type": "object",

     

       79
       79
       +
             "properties": {

     

       80
       80
       +
               "id": {

     

       81
       81
       +
                 "type": "string",

     

       82
       82
       +
                 "description": "The unique identifier of the actor."

     

       83
       83
       +
               },

     

       84
       84
       +
               "did": {

     

       85
       85
       +
                 "type": "string",

     

       86
       86
       +
                 "description": "The DID of the listener."

     

       87
       87
       +
               },

     

       88
       88
       +
               "handle": {

     

       89
       89
       +
                 "type": "string",

     

       90
       90
       +
                 "description": "The handle of the listener."

     

       91
       91
       +
               },

     

       92
       92
       +
               "displayName": {

     

       93
       93
       +
                 "type": "string",

     

       94
       94
       +
                 "description": "The display name of the listener."

     

       95
       95
       +
               },

     

       96
       96
       +
               "avatar": {

     

       97
       97
       +
                 "type": "string",

     

       98
       98
       +
                 "description": "The URL of the listener's avatar image.",

     

       99
       99
       +
                 "format": "uri"

     

       100
       100
       +
               },

     

       101
       101
       +
               "mostListenedSong": {

     

       102
       102
       +
                 "type": "ref",

     

       103
       103
       +
                 "ref": "app.rocksky.song.defs#songViewBasic"

     

       104
       104
       +
               }

     

       105
       105
       +
             }

     

       76
       106
        
           }

     

       77
       107
        
         }

     

       78
       108
        
       }

+38

apps/api/lexicons/artist/getArtistListeners.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.artist.getArtistListeners",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get artist listeners",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "uri"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "uri": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The URI of the artist to retrieve listeners from",

     

       17
       17
       +
                   "format": "at-uri"

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "object",

     

       25
       25
       +
                 "properties": {

     

       26
       26
       +
                   "listeners": {

     

       27
       27
       +
                     "type": "array",

     

       28
       28
       +
                     "items": {

     

       29
       29
       +
                       "type": "ref",

     

       30
       30
       +
                       "ref": "app.rocksky.artist.defs#listenerViewBasic"

     

       31
       31
       +
                     }

     

       32
       32
       +
                   }

     

       33
       33
       +
                 }

     

       34
       34
       +
               }

     

       35
       35
       +
             }

     

       36
       36
       +
           }

     

       37
       37
       +
         }

     

       38
       38
       +
       }

+36

apps/api/pkl/defs/artist/defs.pkl

···

       90
       90
        
       

     

       91
       91
        
           }

     

       92
       92
        
         }

     

       93
       93
       +
       

     

       94
       94
       +
         ["listenerViewBasic"] {

     

       95
       95
       +
           type = "object"

     

       96
       96
       +
           properties {

     

       97
       97
       +
             ["id"] = new StringType {

     

       98
       98
       +
               type = "string"

     

       99
       99
       +
               description = "The unique identifier of the actor."

     

       100
       100
       +
             }

     

       101
       101
       +
       

     

       102
       102
       +
             ["did"] = new StringType {

     

       103
       103
       +
               type = "string"

     

       104
       104
       +
               description = "The DID of the listener."

     

       105
       105
       +
             }

     

       106
       106
       +
       

     

       107
       107
       +
             ["handle"] = new StringType {

     

       108
       108
       +
               type = "string"

     

       109
       109
       +
               description = "The handle of the listener."

     

       110
       110
       +
             }

     

       111
       111
       +
       

     

       112
       112
       +
             ["displayName"] = new StringType {

     

       113
       113
       +
               type = "string"

     

       114
       114
       +
               description = "The display name of the listener."

     

       115
       115
       +
             }

     

       116
       116
       +
       

     

       117
       117
       +
             ["avatar"] = new StringType {

     

       118
       118
       +
               type = "string"

     

       119
       119
       +
               format = "uri"

     

       120
       120
       +
               description = "The URL of the listener's avatar image."

     

       121
       121
       +
             }

     

       122
       122
       +
       

     

       123
       123
       +
             ["mostListenedSong"] = new Ref {

     

       124
       124
       +
               ref = "app.rocksky.song.defs#songViewBasic"

     

       125
       125
       +
             }

     

       126
       126
       +
       

     

       127
       127
       +
           }

     

       128
       128
       +
         }

     

       93
       129
        
       }

+33

apps/api/pkl/defs/artist/getArtistListeners.pkl

···

       1
       1
       +
       amends  "../../schema/lexicon.pkl"

     

       2
       2
       +
       

     

       3
       3
       +
       lexicon = 1

     

       4
       4
       +
       id = "app.rocksky.artist.getArtistListeners"

     

       5
       5
       +
       defs = new Mapping<String, Query> {

     

       6
       6
       +
         ["main"] {

     

       7
       7
       +
           type = "query"

     

       8
       8
       +
           description = "Get artist listeners"

     

       9
       9
       +
           parameters = new Params {

     

       10
       10
       +
             required = List("uri")

     

       11
       11
       +
             properties {

     

       12
       12
       +
               ["uri"] = new StringType {

     

       13
       13
       +
                 description = "The URI of the artist to retrieve listeners from"

     

       14
       14
       +
                 format = "at-uri"

     

       15
       15
       +
               }

     

       16
       16
       +
             }

     

       17
       17
       +
           }

     

       18
       18
       +
           output {

     

       19
       19
       +
             encoding = "application/json"

     

       20
       20
       +
             schema = new ObjectType {

     

       21
       21
       +
               type = "object"

     

       22
       22
       +
               properties = new Mapping<String, Array> {

     

       23
       23
       +
                 ["listeners"] = new Array {

     

       24
       24
       +
                   type = "array"

     

       25
       25
       +
                   items = new Ref {

     

       26
       26
       +
                     ref = "app.rocksky.artist.defs#listenerViewBasic"

     

       27
       27
       +
                   }

     

       28
       28
       +
                 }

     

       29
       29
       +
               }

     

       30
       30
       +
             }

     

       31
       31
       +
           }

     

       32
       32
       +
         }

     

       33
       33
       +
       }

+12

apps/api/src/lexicon/index.ts

···

       25
       25
        
       import type * as AppRockskyApikeyUpdateApikey from './types/app/rocksky/apikey/updateApikey'

     

       26
       26
        
       import type * as AppRockskyArtistGetArtistAlbums from './types/app/rocksky/artist/getArtistAlbums'

     

       27
       27
        
       import type * as AppRockskyArtistGetArtist from './types/app/rocksky/artist/getArtist'

     

       28
       28
       +
       import type * as AppRockskyArtistGetArtistListeners from './types/app/rocksky/artist/getArtistListeners'

     

       28
       29
        
       import type * as AppRockskyArtistGetArtists from './types/app/rocksky/artist/getArtists'

     

       29
       30
        
       import type * as AppRockskyArtistGetArtistTracks from './types/app/rocksky/artist/getArtistTracks'

     

       30
       31
        
       import type * as AppRockskyChartsGetScrobblesChart from './types/app/rocksky/charts/getScrobblesChart'

     
···

       358
       359
        
           return this._server.xrpc.method(nsid, cfg)

     

       359
       360
        
         }

     

       360
       361
        
       

     

       362
       362
       +
         getArtistListeners<AV extends AuthVerifier>(

     

       363
       363
       +
           cfg: ConfigOf<

     

       364
       364
       +
             AV,

     

       365
       365
       +
             AppRockskyArtistGetArtistListeners.Handler<ExtractAuth<AV>>,

     

       366
       366
       +
             AppRockskyArtistGetArtistListeners.HandlerReqCtx<ExtractAuth<AV>>

     

       367
       367
       +
           >,

     

       368
       368
       +
         ) {

     

       369
       369
       +
           const nsid = 'app.rocksky.artist.getArtistListeners' // @ts-ignore

     

       370
       370
       +
           return this._server.xrpc.method(nsid, cfg)

     

       371
       371
       +
         }

     

       372
       372
       +
       

     

       361
       373
        
         getArtists<AV extends AuthVerifier>(

     

       362
       374
        
           cfg: ConfigOf<

     

       363
       375
        
             AV,

+67

apps/api/src/lexicon/lexicons.ts

···

       1066
       1066
        
                 },

     

       1067
       1067
        
               },

     

       1068
       1068
        
             },

     

       1069
       1069
       +
             listenerViewBasic: {

     

       1070
       1070
       +
               type: 'object',

     

       1071
       1071
       +
               properties: {

     

       1072
       1072
       +
                 id: {

     

       1073
       1073
       +
                   type: 'string',

     

       1074
       1074
       +
                   description: 'The unique identifier of the actor.',

     

       1075
       1075
       +
                 },

     

       1076
       1076
       +
                 did: {

     

       1077
       1077
       +
                   type: 'string',

     

       1078
       1078
       +
                   description: 'The DID of the listener.',

     

       1079
       1079
       +
                 },

     

       1080
       1080
       +
                 handle: {

     

       1081
       1081
       +
                   type: 'string',

     

       1082
       1082
       +
                   description: 'The handle of the listener.',

     

       1083
       1083
       +
                 },

     

       1084
       1084
       +
                 displayName: {

     

       1085
       1085
       +
                   type: 'string',

     

       1086
       1086
       +
                   description: 'The display name of the listener.',

     

       1087
       1087
       +
                 },

     

       1088
       1088
       +
                 avatar: {

     

       1089
       1089
       +
                   type: 'string',

     

       1090
       1090
       +
                   description: "The URL of the listener's avatar image.",

     

       1091
       1091
       +
                   format: 'uri',

     

       1092
       1092
       +
                 },

     

       1093
       1093
       +
                 mostListenedSong: {

     

       1094
       1094
       +
                   type: 'ref',

     

       1095
       1095
       +
                   ref: 'lex:app.rocksky.song.defs#songViewBasic',

     

       1096
       1096
       +
                 },

     

       1097
       1097
       +
               },

     

       1098
       1098
       +
             },

     

       1069
       1099
        
           },

     

       1070
       1100
        
         },

     

       1071
       1101
        
         AppRockskyArtistGetArtistAlbums: {

     
···

       1132
       1162
        
             },

     

       1133
       1163
        
           },

     

       1134
       1164
        
         },

     

       1165
       1165
       +
         AppRockskyArtistGetArtistListeners: {

     

       1166
       1166
       +
           lexicon: 1,

     

       1167
       1167
       +
           id: 'app.rocksky.artist.getArtistListeners',

     

       1168
       1168
       +
           defs: {

     

       1169
       1169
       +
             main: {

     

       1170
       1170
       +
               type: 'query',

     

       1171
       1171
       +
               description: 'Get artist listeners',

     

       1172
       1172
       +
               parameters: {

     

       1173
       1173
       +
                 type: 'params',

     

       1174
       1174
       +
                 required: ['uri'],

     

       1175
       1175
       +
                 properties: {

     

       1176
       1176
       +
                   uri: {

     

       1177
       1177
       +
                     type: 'string',

     

       1178
       1178
       +
                     description: 'The URI of the artist to retrieve listeners from',

     

       1179
       1179
       +
                     format: 'at-uri',

     

       1180
       1180
       +
                   },

     

       1181
       1181
       +
                 },

     

       1182
       1182
       +
               },

     

       1183
       1183
       +
               output: {

     

       1184
       1184
       +
                 encoding: 'application/json',

     

       1185
       1185
       +
                 schema: {

     

       1186
       1186
       +
                   type: 'object',

     

       1187
       1187
       +
                   properties: {

     

       1188
       1188
       +
                     listeners: {

     

       1189
       1189
       +
                       type: 'array',

     

       1190
       1190
       +
                       items: {

     

       1191
       1191
       +
                         type: 'ref',

     

       1192
       1192
       +
                         ref: 'lex:app.rocksky.artist.defs#listenerViewBasic',

     

       1193
       1193
       +
                       },

     

       1194
       1194
       +
                     },

     

       1195
       1195
       +
                   },

     

       1196
       1196
       +
                 },

     

       1197
       1197
       +
               },

     

       1198
       1198
       +
             },

     

       1199
       1199
       +
           },

     

       1200
       1200
       +
         },

     

       1135
       1201
        
         AppRockskyArtistGetArtists: {

     

       1136
       1202
        
           lexicon: 1,

     

       1137
       1203
        
           id: 'app.rocksky.artist.getArtists',

     
···

       4321
       4387
        
         AppRockskyArtistDefs: 'app.rocksky.artist.defs',

     

       4322
       4388
        
         AppRockskyArtistGetArtistAlbums: 'app.rocksky.artist.getArtistAlbums',

     

       4323
       4389
        
         AppRockskyArtistGetArtist: 'app.rocksky.artist.getArtist',

     

       4390
       4390
       +
         AppRockskyArtistGetArtistListeners: 'app.rocksky.artist.getArtistListeners',

     

       4324
       4391
        
         AppRockskyArtistGetArtists: 'app.rocksky.artist.getArtists',

     

       4325
       4392
        
         AppRockskyArtistGetArtistTracks: 'app.rocksky.artist.getArtistTracks',

     

       4326
       4393
        
         AppRockskyChartsDefs: 'app.rocksky.charts.defs',

+28

apps/api/src/lexicon/types/app/rocksky/artist/defs.ts

···

       5
       5
        
       import { lexicons } from '../../../../lexicons'

     

       6
       6
        
       import { isObj, hasProp } from '../../../../util'

     

       7
       7
        
       import { CID } from 'multiformats/cid'

     

       8
       8
       +
       import type * as AppRockskySongDefs from '../song/defs'

     

       8
       9
        
       

     

       9
       10
        
       export interface ArtistViewBasic {

     

       10
       11
        
         /** The unique identifier of the artist. */

     
···

       65
       66
        
       export function validateArtistViewDetailed(v: unknown): ValidationResult {

     

       66
       67
        
         return lexicons.validate('app.rocksky.artist.defs#artistViewDetailed', v)

     

       67
       68
        
       }

     

       69
       69
       +
       

     

       70
       70
       +
       export interface ListenerViewBasic {

     

       71
       71
       +
         /** The unique identifier of the actor. */

     

       72
       72
       +
         id?: string

     

       73
       73
       +
         /** The DID of the listener. */

     

       74
       74
       +
         did?: string

     

       75
       75
       +
         /** The handle of the listener. */

     

       76
       76
       +
         handle?: string

     

       77
       77
       +
         /** The display name of the listener. */

     

       78
       78
       +
         displayName?: string

     

       79
       79
       +
         /** The URL of the listener's avatar image. */

     

       80
       80
       +
         avatar?: string

     

       81
       81
       +
         mostListenedSong?: AppRockskySongDefs.SongViewBasic

     

       82
       82
       +
         [k: string]: unknown

     

       83
       83
       +
       }

     

       84
       84
       +
       

     

       85
       85
       +
       export function isListenerViewBasic(v: unknown): v is ListenerViewBasic {

     

       86
       86
       +
         return (

     

       87
       87
       +
           isObj(v) &&

     

       88
       88
       +
           hasProp(v, '$type') &&

     

       89
       89
       +
           v.$type === 'app.rocksky.artist.defs#listenerViewBasic'

     

       90
       90
       +
         )

     

       91
       91
       +
       }

     

       92
       92
       +
       

     

       93
       93
       +
       export function validateListenerViewBasic(v: unknown): ValidationResult {

     

       94
       94
       +
         return lexicons.validate('app.rocksky.artist.defs#listenerViewBasic', v)

     

       95
       95
       +
       }

+48

apps/api/src/lexicon/types/app/rocksky/artist/getArtistListeners.ts

···

       1
       1
       +
       /**

     

       2
       2
       +
        * GENERATED CODE - DO NOT MODIFY

     

       3
       3
       +
        */

     

       4
       4
       +
       import type express from 'express'

     

       5
       5
       +
       import { ValidationResult, BlobRef } from '@atproto/lexicon'

     

       6
       6
       +
       import { lexicons } from '../../../../lexicons'

     

       7
       7
       +
       import { isObj, hasProp } from '../../../../util'

     

       8
       8
       +
       import { CID } from 'multiformats/cid'

     

       9
       9
       +
       import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'

     

       10
       10
       +
       import type * as AppRockskyArtistDefs from './defs'

     

       11
       11
       +
       

     

       12
       12
       +
       export interface QueryParams {

     

       13
       13
       +
         /** The URI of the artist to retrieve listeners from */

     

       14
       14
       +
         uri: string

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       export type InputSchema = undefined

     

       18
       18
       +
       

     

       19
       19
       +
       export interface OutputSchema {

     

       20
       20
       +
         listeners?: AppRockskyArtistDefs.ListenerViewBasic[]

     

       21
       21
       +
         [k: string]: unknown

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       export type HandlerInput = undefined

     

       25
       25
       +
       

     

       26
       26
       +
       export interface HandlerSuccess {

     

       27
       27
       +
         encoding: 'application/json'

     

       28
       28
       +
         body: OutputSchema

     

       29
       29
       +
         headers?: { [key: string]: string }

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       export interface HandlerError {

     

       33
       33
       +
         status: number

     

       34
       34
       +
         message?: string

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough

     

       38
       38
       +
       export type HandlerReqCtx<HA extends HandlerAuth = never> = {

     

       39
       39
       +
         auth: HA

     

       40
       40
       +
         params: QueryParams

     

       41
       41
       +
         input: HandlerInput

     

       42
       42
       +
         req: express.Request

     

       43
       43
       +
         res: express.Response

     

       44
       44
       +
         resetRouteRateLimits: () => Promise<void>

     

       45
       45
       +
       }

     

       46
       46
       +
       export type Handler<HA extends HandlerAuth = never> = (

     

       47
       47
       +
         ctx: HandlerReqCtx<HA>,

     

       48
       48
       +
       ) => Promise<HandlerOutput> | HandlerOutput

+126 -1

crates/analytics/src/handlers/artists.rs

···

       3
       3
        
       use crate::types::{

     

       4
       4
        
           album::Album,

     

       5
       5
        
           artist::{

     

       6
       6
       -
               Artist, GetArtistAlbumsParams, GetArtistTracksParams, GetArtistsParams, GetTopArtistsParams,

     

       6
       6
       +
               Artist, ArtistListener, GetArtistAlbumsParams, GetArtistListenersParams,

     

       7
       7
       +
               GetArtistTracksParams, GetArtistsParams, GetTopArtistsParams,

     

       7
       8
        
           },

     

       8
       9
        
           track::Track,

     

       9
       10
        
       };

     
···

       364
       365
        
           let albums: Result<Vec<_>, _> = albums.collect();

     

       365
       366
        
           Ok(HttpResponse::Ok().json(albums?))

     

       366
       367
        
       }

     

       368
       368
       +
       

     

       369
       369
       +
       pub async fn get_artist_listeners(

     

       370
       370
       +
           payload: &mut web::Payload,

     

       371
       371
       +
           _req: &HttpRequest,

     

       372
       372
       +
           conn: Arc<Mutex<Connection>>,

     

       373
       373
       +
       ) -> Result<HttpResponse, Error> {

     

       374
       374
       +
           let body = read_payload!(payload);

     

       375
       375
       +
           let params = serde_json::from_slice::<GetArtistListenersParams>(&body)?;

     

       376
       376
       +
           let pagination = params.pagination.unwrap_or_default();

     

       377
       377
       +
           let offset = pagination.skip.unwrap_or(0);

     

       378
       378
       +
           let limit = pagination.take.unwrap_or(10);

     

       379
       379
       +
       

     

       380
       380
       +
           let conn = conn.lock().unwrap();

     

       381
       381
       +
           let mut stmt =

     

       382
       382
       +
               conn.prepare("SELECT id, name, uri FROM artists WHERE id = ? OR uri = ? OR name = ?")?;

     

       383
       383
       +
           let artist = stmt.query_row(

     

       384
       384
       +
               [&params.artist_id, &params.artist_id, &params.artist_id],

     

       385
       385
       +
               |row| {

     

       386
       386
       +
                   Ok(crate::types::artist::ArtistBasic {

     

       387
       387
       +
                       id: row.get(0)?,

     

       388
       388
       +
                       name: row.get(1)?,

     

       389
       389
       +
                       uri: row.get(2)?,

     

       390
       390
       +
                   })

     

       391
       391
       +
               },

     

       392
       392
       +
           )?;

     

       393
       393
       +
       

     

       394
       394
       +
           if artist.id.is_empty() {

     

       395
       395
       +
               return Ok(HttpResponse::Ok().json(Vec::<ArtistListener>::new()));

     

       396
       396
       +
           }

     

       397
       397
       +
       

     

       398
       398
       +
           let mut stmt = conn.prepare(

     

       399
       399
       +
               r#"

     

       400
       400
       +
               WITH user_track_counts AS (

     

       401
       401
       +
               SELECT

     

       402
       402
       +
                   s.user_id,

     

       403
       403
       +
                   s.track_id,

     

       404
       404
       +
                   t.artist,

     

       405
       405
       +
                   t.title as track_title,

     

       406
       406
       +
                   t.uri as track_uri,

     

       407
       407
       +
                   COUNT(*) as play_count

     

       408
       408
       +
               FROM scrobbles s

     

       409
       409
       +
               JOIN tracks t ON s.track_id = t.id

     

       410
       410
       +
               WHERE t.artist = ?

     

       411
       411
       +
               GROUP BY s.user_id, s.track_id, t.artist, t.title, t.uri

     

       412
       412
       +
           ),

     

       413
       413
       +
           user_top_tracks AS (

     

       414
       414
       +
               SELECT

     

       415
       415
       +
                   user_id,

     

       416
       416
       +
                   artist,

     

       417
       417
       +
                   track_id,

     

       418
       418
       +
                   track_title,

     

       419
       419
       +
                   track_uri,

     

       420
       420
       +
                   play_count,

     

       421
       421
       +
                   ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY play_count DESC, track_title) as rn

     

       422
       422
       +
               FROM user_track_counts

     

       423
       423
       +
           ),

     

       424
       424
       +
           artist_listener_counts AS (

     

       425
       425
       +
               SELECT

     

       426
       426
       +
                   user_id,

     

       427
       427
       +
                   artist,

     

       428
       428
       +
                   SUM(play_count) as total_artist_plays

     

       429
       429
       +
               FROM user_track_counts

     

       430
       430
       +
               GROUP BY user_id, artist

     

       431
       431
       +
           ),

     

       432
       432
       +
           top_artist_listeners AS (

     

       433
       433
       +
               SELECT

     

       434
       434
       +
                   user_id,

     

       435
       435
       +
                   artist,

     

       436
       436
       +
                   total_artist_plays,

     

       437
       437
       +
                   ROW_NUMBER() OVER (ORDER BY total_artist_plays DESC) as listener_rank

     

       438
       438
       +
               FROM artist_listener_counts

     

       439
       439
       +
           ),

     

       440
       440
       +
           paginated_listeners AS (

     

       441
       441
       +
               SELECT

     

       442
       442
       +
                   user_id,

     

       443
       443
       +
                   artist,

     

       444
       444
       +
                   total_artist_plays,

     

       445
       445
       +
                   listener_rank

     

       446
       446
       +
               FROM top_artist_listeners

     

       447
       447
       +
               ORDER BY listener_rank

     

       448
       448
       +
               LIMIT ? OFFSET ?

     

       449
       449
       +
           )

     

       450
       450
       +
           SELECT

     

       451
       451
       +
               pl.artist,

     

       452
       452
       +
               pl.listener_rank,

     

       453
       453
       +
               u.id as user_id,

     

       454
       454
       +
               u.display_name,

     

       455
       455
       +
               u.did,

     

       456
       456
       +
               u.handle,

     

       457
       457
       +
               u.avatar,

     

       458
       458
       +
               pl.total_artist_plays,

     

       459
       459
       +
               utt.track_title as most_played_track,

     

       460
       460
       +
               utt.track_uri as most_played_track_uri,

     

       461
       461
       +
               utt.play_count as track_play_count

     

       462
       462
       +
           FROM paginated_listeners pl

     

       463
       463
       +
           JOIN users u ON pl.user_id = u.id

     

       464
       464
       +
           JOIN user_top_tracks utt ON pl.user_id = utt.user_id

     

       465
       465
       +
               AND utt.rn = 1

     

       466
       466
       +
           ORDER BY pl.listener_rank;

     

       467
       467
       +
           "#,

     

       468
       468
       +
           )?;

     

       469
       469
       +
       

     

       470
       470
       +
           let listeners = stmt.query_map(

     

       471
       471
       +
               [&artist.name, &limit.to_string(), &offset.to_string()],

     

       472
       472
       +
               |row| {

     

       473
       473
       +
                   Ok(ArtistListener {

     

       474
       474
       +
                       artist: row.get(0)?,

     

       475
       475
       +
                       listener_rank: row.get(1)?,

     

       476
       476
       +
                       user_id: row.get(2)?,

     

       477
       477
       +
                       display_name: row.get(3)?,

     

       478
       478
       +
                       did: row.get(4)?,

     

       479
       479
       +
                       handle: row.get(5)?,

     

       480
       480
       +
                       avatar: row.get(6)?,

     

       481
       481
       +
                       total_artist_plays: row.get(7)?,

     

       482
       482
       +
                       most_played_track: row.get(8)?,

     

       483
       483
       +
                       most_played_track_uri: row.get(9)?,

     

       484
       484
       +
                       track_play_count: row.get(10)?,

     

       485
       485
       +
                   })

     

       486
       486
       +
               },

     

       487
       487
       +
           )?;

     

       488
       488
       +
       

     

       489
       489
       +
           let listeners: Result<Vec<_>, _> = listeners.collect();

     

       490
       490
       +
           Ok(HttpResponse::Ok().json(listeners?))

     

       491
       491
       +
       }

crates/analytics/src/handlers/mod.rs

···

       12
       12
        
       };

     

       13
       13
        
       use tracks::{get_loved_tracks, get_top_tracks, get_tracks};

     

       14
       14
        
       

     

       15
       15
       +
       use crate::handlers::artists::get_artist_listeners;

     

       16
       16
       +
       

     

       15
       17
        
       pub mod albums;

     

       16
       18
        
       pub mod artists;

     

       17
       19
        
       pub mod scrobbles;

     
···

       58
       60
        
               "library.getAlbumTracks" => get_album_tracks(payload, req, conn.clone()).await,

     

       59
       61
        
               "library.getArtistAlbums" => get_artist_albums(payload, req, conn.clone()).await,

     

       60
       62
        
               "library.getArtistTracks" => get_artist_tracks(payload, req, conn.clone()).await,

     

       63
       63
       +
               "library.getArtistListeners" => get_artist_listeners(payload, req, conn.clone()).await,

     

       61
       64
        
               _ => return Err(anyhow::anyhow!("Method not found")),

     

       62
       65
        
           }

     

       63
       66
        
       }

+28

crates/analytics/src/types/artist.rs

···

       33
       33
        
           pub unique_listeners: Option<i32>,

     

       34
       34
        
       }

     

       35
       35
        
       

     

       36
       36
       +
       #[derive(Debug, Serialize, Deserialize, Default)]

     

       37
       37
       +
       pub struct ArtistBasic {

     

       38
       38
       +
           pub id: String,

     

       39
       39
       +
           pub name: String,

     

       40
       40
       +
           pub uri: Option<String>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       #[derive(Debug, Serialize, Deserialize, Default)]

     

       44
       44
       +
       pub struct ArtistListener {

     

       45
       45
       +
           pub artist: String,

     

       46
       46
       +
           pub listener_rank: i64,

     

       47
       47
       +
           pub user_id: String,

     

       48
       48
       +
           pub display_name: String,

     

       49
       49
       +
           pub did: String,

     

       50
       50
       +
           pub handle: String,

     

       51
       51
       +
           pub avatar: String,

     

       52
       52
       +
           pub total_artist_plays: i64,

     

       53
       53
       +
           pub most_played_track: String,

     

       54
       54
       +
           pub most_played_track_uri: String,

     

       55
       55
       +
           pub track_play_count: i64,

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       36
       58
        
       #[derive(Debug, Serialize, Deserialize, Default)]

     

       37
       59
        
       pub struct GetArtistsParams {

     

       38
       60
        
           pub user_did: Option<String>,

     
···

       55
       77
        
       pub struct GetArtistAlbumsParams {

     

       56
       78
        
           pub artist_id: String,

     

       57
       79
        
       }

     

       80
       80
       +
       

     

       81
       81
       +
       #[derive(Debug, Serialize, Deserialize, Default)]

     

       82
       82
       +
       pub struct GetArtistListenersParams {

     

       83
       83
       +
           pub artist_id: String,

     

       84
       84
       +
           pub pagination: Option<Pagination>,

     

       85
       85
       +
       }