def get_recording_recommendation_events(users_for_events: List[dict],
                                        min_ts: int, max_ts: int,
                                        count: int) -> List[APITimelineEvent]:
    """ Gets all recording recommendation events in the feed.
    """

    id_username_map = {
        user['id']: user['musicbrainz_id']
        for user in users_for_events
    }
    recording_recommendation_events_db = db_user_timeline_event.get_recording_recommendation_events_for_feed(
        user_ids=(user['id'] for user in users_for_events),
        min_ts=min_ts,
        max_ts=max_ts,
        count=count,
    )

    events = []
    for event in recording_recommendation_events_db:
        try:
            listen = APIListen(
                user_name=id_username_map[event.user_id],
                track_metadata=TrackMetadata(
                    artist_name=event.metadata.artist_name,
                    track_name=event.metadata.track_name,
                    release_name=event.metadata.release_name,
                    additional_info=AdditionalInfo(
                        recording_msid=event.metadata.recording_msid,
                        recording_mbid=event.metadata.recording_mbid,
                        artist_msid=event.metadata.artist_msid,
                    )),
            )

            events.append(
                APITimelineEvent(
                    id=event.id,
                    event_type=UserTimelineEventType.RECORDING_RECOMMENDATION,
                    user_name=listen.user_name,
                    created=event.created.timestamp(),
                    metadata=listen,
                ))
        except pydantic.ValidationError as e:
            current_app.logger.error('Validation error: ' + str(e),
                                     exc_info=True)
            continue
    return events
def get_recording_pin_events(users_for_events: List[dict], min_ts: int,
                             max_ts: int,
                             count: int) -> List[APITimelineEvent]:
    """ Gets all recording pin events in the feed."""

    id_username_map = {
        user['id']: user['musicbrainz_id']
        for user in users_for_events
    }
    recording_pin_events_db = get_pins_for_feed(
        user_ids=(user['id'] for user in users_for_events),
        min_ts=min_ts,
        max_ts=max_ts,
        count=count,
    )
    recording_pin_events_db = fetch_track_metadata_for_pins(
        recording_pin_events_db)

    events = []
    for pin in recording_pin_events_db:
        try:
            pinEvent = APIPinEvent(
                user_name=id_username_map[pin.user_id],
                blurb_content=pin.blurb_content,
                track_metadata=TrackMetadata(
                    artist_name=pin.track_metadata["artist_name"],
                    track_name=pin.track_metadata["track_name"],
                    release_name=None,
                    additional_info=AdditionalInfo(
                        recording_msid=pin.recording_msid,
                        recording_mbid=pin.recording_mbid,
                        artist_msid=pin.track_metadata["artist_msid"],
                    )))
            events.append(
                APITimelineEvent(
                    event_type=UserTimelineEventType.RECORDING_PIN,
                    user_name=pinEvent.user_name,
                    created=pin.created.timestamp(),
                    metadata=pinEvent,
                ))
        except pydantic.ValidationError as e:
            current_app.logger.error('Validation error: ' + str(e),
                                     exc_info=True)
            continue
    return events