def get_listening_history(user, max_hs, offset, dismissed=None):
    if dismissed is None:
        listening_histories = ListeningHistory.\
          query.\
          filter(ListeningHistory.user_id == user.id).\
          order_by(ListeningHistory.updated_at.desc()).\
          limit(max_hs).\
          offset(offset).\
          all()
    else:
        listening_histories = ListeningHistory.\
          query.\
          filter(ListeningHistory.user_id == user.id,
                 ListeningHistory.dismissed == dismissed,
                 ListeningHistory.current_progress > 0.01,
                 ListeningHistory.current_progress < 0.99).\
          order_by(ListeningHistory.updated_at.desc()).\
          limit(max_hs).\
          offset(offset).\
          all()

    episodes = \
      episodes_dao.get_episodes([h.episode_id for h in listening_histories],
                                user.id)

    episode_id_to_episode = {e.id: e for e in episodes}
    for lh in listening_histories:
        lh.episode = episode_id_to_episode[lh.episode_id]

    return listening_histories
def get_listening_history(user, max_hs, offset, dismissed=None):
  if dismissed is None:
    listening_histories = ListeningHistory.\
      query.\
      filter(ListeningHistory.user_id == user.id).\
      order_by(ListeningHistory.updated_at.desc()).\
      limit(max_hs).\
      offset(offset).\
      all()
  else:
    listening_histories = ListeningHistory.\
      query.\
      filter(ListeningHistory.user_id == user.id,
             ListeningHistory.dismissed == dismissed,
             ListeningHistory.current_progress > 0.01,
             ListeningHistory.current_progress < 0.99).\
      order_by(ListeningHistory.updated_at.desc()).\
      limit(max_hs).\
      offset(offset).\
      all()

  episodes = \
    episodes_dao.get_episodes([h.episode_id for h in listening_histories],
                              user.id)

  episode_id_to_episode = {e.id:e for e in episodes}
  for lh in listening_histories:
    lh.episode = episode_id_to_episode[lh.episode_id]

  return listening_histories
示例#3
0
def get_user_bookmarks(user):
  bookmarks = Bookmark.query.filter(Bookmark.user_id == user.id).all()
  episodes = episodes_dao.get_episodes([b.episode_id for b in bookmarks],
                                       user.id)
  episode_id_to_episode = {e.id:e for e in episodes}
  for b in bookmarks:
    b.episode = episode_id_to_episode[b.episode_id]
  return bookmarks
示例#4
0
def get_episode_recommendations(episode_id, user_id, max_recs, offset):
  recommendations = (
      Recommendation.query.filter(Recommendation.episode_id == episode_id)
      .limit(max_recs)
      .offset(offset)
      .all()
  )
  episodes = episodes_dao.get_episodes([r.episode_id for r in recommendations],
                                       user_id)
  episode_id_to_episode = {e.id:e for e in episodes}
  for r in recommendations:
    r.episode = episode_id_to_episode[r.episode_id]
  return recommendations
示例#5
0
def get_user_recommendations(caller_user_id, requested_user_id):
  recommendations = (
      Recommendation.query.\
      filter(Recommendation.user_id == requested_user_id).\
      order_by(Recommendation.created_at.desc()).
      all()
  )
  episodes = episodes_dao.get_episodes([r.episode_id for r in recommendations],
                                       caller_user_id)
  episode_id_to_episode = {e.id:e for e in episodes}
  for r in recommendations:
    r.episode = episode_id_to_episode[r.episode_id]
  return recommendations
示例#6
0
def get_shared_with_user(user_id, max_shares, offset):
    shares = Share.query.filter(Share.sharee_id == user_id) \
              .limit(max_shares) \
              .offset(offset) \
              .all()
    episodes = episodes_dao.get_episodes([s.episode_id for s in shares],
                                         user_id)

    # Ensure episodes match up
    episode_map = {e.id: e for e in episodes}
    for s in shares:
        s.episode = episode_map[s.episode_id]

    return shares
def create_or_update_listening_histories(episode_update_info_map, user):
    episode_ids = episode_update_info_map.keys()

    listening_histories = \
      ListeningHistory.query.filter(ListeningHistory.episode_id.in_(episode_ids),
                                    ListeningHistory.user_id == user.id).all()
    listening_histories_by_episode = \
      {lh.episode_id: lh for lh in listening_histories}
    result = []
    for episode_id in episode_ids:
        try:
            current_progress = \
              episode_update_info_map[episode_id]['current_progress']
            percentage_listened = \
              episode_update_info_map[episode_id]['percentage_listened']
        except KeyError:
            raise Exception(
                'Invalid episode_id {} provided'.format(episode_id))
        if episode_id in listening_histories_by_episode:
            lh = listening_histories_by_episode[episode_id]
            lh.current_progress = current_progress
            lh.percentage_listened = lh.percentage_listened + percentage_listened
            lh.dismissed = False
        else:
            lh = \
              ListeningHistory(episode_id=episode_id, user_id=user.id,
                               percentage_listened=percentage_listened,
                               current_progress=current_progress)
            db.session.add(lh)
        result.append(lh)
    # Update episode durations if needed
    episode_ids_to_query = \
      [k for k, v in episode_update_info_map.items() if 'real_duration' in v]
    episodes = episodes_dao.get_episodes(episode_ids_to_query, user.id)
    for episode in episodes:
        # if not episode.real_duration_written: DISABLED FOR NOW TO FIX BAD VALUES
        episode.duration = episode_update_info_map[episode.id]['real_duration']
        episode.real_duration_written = True
    db_utils.db_session_commit()
    return result
def create_or_update_listening_histories(episode_update_info_map, user):
  episode_ids = episode_update_info_map.keys()

  listening_histories = \
    ListeningHistory.query.filter(ListeningHistory.episode_id.in_(episode_ids),
                                  ListeningHistory.user_id == user.id).all()
  listening_histories_by_episode = \
    {lh.episode_id: lh for lh in listening_histories}
  result = []
  for episode_id in episode_ids:
    try:
      current_progress = \
        episode_update_info_map[episode_id]['current_progress']
      percentage_listened = \
        episode_update_info_map[episode_id]['percentage_listened']
    except KeyError:
      raise Exception('Invalid episode_id {} provided'.format(episode_id))
    if episode_id in listening_histories_by_episode:
      lh = listening_histories_by_episode[episode_id]
      lh.current_progress = current_progress
      lh.percentage_listened = lh.percentage_listened + percentage_listened
      lh.dismissed = False
    else:
      lh = \
        ListeningHistory(episode_id=episode_id, user_id=user.id,
                         percentage_listened=percentage_listened,
                         current_progress=current_progress)
      db.session.add(lh)
    result.append(lh)
  # Update episode durations if needed
  episode_ids_to_query = \
    [k for k, v in episode_update_info_map.items() if 'real_duration' in v]
  episodes = episodes_dao.get_episodes(episode_ids_to_query, user.id)
  for episode in episodes:
    # if not episode.real_duration_written: DISABLED FOR NOW TO FIX BAD VALUES
    episode.duration = episode_update_info_map[episode.id]['real_duration']
    episode.real_duration_written = True
  db_utils.db_session_commit()
  return result