From c98a8865d6547dfd7f86d02065ee3dac2af65312 Mon Sep 17 00:00:00 2001
From: Tim <timvdwest@gmail.com>
Date: Sun, 16 Aug 2015 12:40:32 +0200
Subject: [PATCH] Fix bug where user refresh would fail under certain
 circumstances. Move all user functions to it's own class.

---
 data/interfaces/default/edit_user.html |   2 +-
 plexpy/datafactory.py                  | 441 -----------------------
 plexpy/monitor.py                      |   6 +-
 plexpy/notification_handler.py         |   6 +-
 plexpy/plextv.py                       |  25 +-
 plexpy/plexwatch_import.py             |   8 +-
 plexpy/pmsconnect.py                   |   8 +-
 plexpy/users.py                        | 463 +++++++++++++++++++++++++
 plexpy/webserve.py                     |  63 ++--
 9 files changed, 522 insertions(+), 500 deletions(-)
 create mode 100644 plexpy/users.py

diff --git a/data/interfaces/default/edit_user.html b/data/interfaces/default/edit_user.html
index 213427df..37aba8bb 100644
--- a/data/interfaces/default/edit_user.html
+++ b/data/interfaces/default/edit_user.html
@@ -44,7 +44,7 @@ DOCUMENTATION :: END
                             <input type="text" class="form-control" id="profile_url" name="profile_url" value="${data['thumb']}">
                         </div>
                     </div>
-                    <p class="help-block">Change the users profile picture in PlexPy.</p>
+                    <p class="help-block">Change the users profile picture in PlexPy. To reset to default, leave this field empty and save then perform a user refresh.</p>
                 </div>
                 <div class="checkbox">
                     <label>
diff --git a/plexpy/datafactory.py b/plexpy/datafactory.py
index 4fdf8bc3..13ab1b54 100644
--- a/plexpy/datafactory.py
+++ b/plexpy/datafactory.py
@@ -26,63 +26,6 @@ class DataFactory(object):
     def __init__(self):
         pass
 
-    def get_user_list(self, kwargs=None):
-        data_tables = datatables.DataTables()
-
-        columns = ['users.user_id as user_id',
-                   'users.custom_avatar_url as thumb',
-                   '(case when users.friendly_name is null then users.username else \
-                    users.friendly_name end) as friendly_name',
-                   'MAX(session_history.started) as last_seen',
-                   'session_history.ip_address as ip_address',
-                   'COUNT(session_history.id) as plays',
-                   'users.username as user'
-                   ]
-        try:
-            query = data_tables.ssp_query(table_name='users',
-                                          columns=columns,
-                                          custom_where=[],
-                                          group_by=['users.user_id'],
-                                          join_types=['LEFT OUTER JOIN'],
-                                          join_tables=['session_history'],
-                                          join_evals=[['session_history.user_id', 'users.user_id']],
-                                          kwargs=kwargs)
-        except:
-            logger.warn("Unable to execute database query.")
-            return {'recordsFiltered': 0,
-                    'recordsTotal': 0,
-                    'draw': 0,
-                    'data': 'null',
-                    'error': 'Unable to execute database query.'}
-
-        users = query['result']
-
-        rows = []
-        for item in users:
-            if not item['thumb'] or item['thumb'] == '':
-                user_thumb = common.DEFAULT_USER_THUMB
-            else:
-                user_thumb = item['thumb']
-
-            row = {"plays": item['plays'],
-                   "last_seen": item['last_seen'],
-                   "friendly_name": item["friendly_name"],
-                   "ip_address": item["ip_address"],
-                   "thumb": user_thumb,
-                   "user": item["user"],
-                   "user_id": item['user_id']
-                   }
-
-            rows.append(row)
-
-        dict = {'recordsFiltered': query['filteredCount'],
-                'recordsTotal': query['totalCount'],
-                'data': rows,
-                'draw': query['draw']
-        }
-
-        return dict
-
     def get_history(self, kwargs=None, custom_where=None):
         data_tables = datatables.DataTables()
 
@@ -167,305 +110,6 @@ class DataFactory(object):
 
         return dict
 
-    def get_user_unique_ips(self, kwargs=None, custom_where=None):
-        data_tables = datatables.DataTables()
-
-        columns = ['session_history.started as last_seen',
-                   'session_history.ip_address as ip_address',
-                   'COUNT(session_history.id) as play_count',
-                   'session_history.player as platform',
-                   'session_history_metadata.full_title as last_watched',
-                   'session_history.user as user',
-                   'session_history.user_id as user_id'
-                   ]
-
-        try:
-            query = data_tables.ssp_query(table_name='session_history',
-                                          columns=columns,
-                                          custom_where=custom_where,
-                                          group_by=['ip_address'],
-                                          join_types=['JOIN'],
-                                          join_tables=['session_history_metadata'],
-                                          join_evals=[['session_history.id', 'session_history_metadata.id']],
-                                          kwargs=kwargs)
-        except:
-            logger.warn("Unable to execute database query.")
-            return {'recordsFiltered': 0,
-                    'recordsTotal': 0,
-                    'draw': 0,
-                    'data': 'null',
-                    'error': 'Unable to execute database query.'}
-
-        results = query['result']
-
-        rows = []
-        for item in results:
-            row = {"last_seen": item['last_seen'],
-                   "ip_address": item['ip_address'],
-                   "play_count": item['play_count'],
-                   "platform": item['platform'],
-                   "last_watched": item['last_watched']
-                   }
-
-            rows.append(row)
-
-        dict = {'recordsFiltered': query['filteredCount'],
-                'recordsTotal': query['totalCount'],
-                'data': rows,
-                'draw': query['draw']
-        }
-
-        return dict
-
-    # TODO: The getter and setter for this needs to become a config getter/setter for more than just friendlyname
-    def set_user_friendly_name(self, user=None, user_id=None, friendly_name=None, do_notify=0, keep_history=1):
-        if user_id:
-            if friendly_name.strip() == '':
-                friendly_name = None
-
-            monitor_db = database.MonitorDatabase()
-
-            control_value_dict = {"user_id": user_id}
-            new_value_dict = {"friendly_name": friendly_name,
-                              "do_notify": do_notify,
-                              "keep_history": keep_history}
-            try:
-                monitor_db.upsert('users', new_value_dict, control_value_dict)
-            except Exception, e:
-                logger.debug(u"Uncaught exception %s" % e)
-        if user:
-            if friendly_name.strip() == '':
-                friendly_name = None
-
-            monitor_db = database.MonitorDatabase()
-
-            control_value_dict = {"username": user}
-            new_value_dict = {"friendly_name": friendly_name,
-                              "do_notify": do_notify,
-                              "keep_history": keep_history}
-            try:
-                monitor_db.upsert('users', new_value_dict, control_value_dict)
-            except Exception, e:
-                logger.debug(u"Uncaught exception %s" % e)
-
-    def set_user_profile_url(self, user=None, user_id=None, profile_url=None):
-        if user_id:
-            if profile_url.strip() == '':
-                profile_url = None
-
-            monitor_db = database.MonitorDatabase()
-
-            control_value_dict = {"user_id": user_id}
-            new_value_dict = {"custom_avatar_url": profile_url}
-            try:
-                monitor_db.upsert('users', new_value_dict, control_value_dict)
-            except Exception, e:
-                logger.debug(u"Uncaught exception %s" % e)
-        if user:
-            if profile_url.strip() == '':
-                profile_url = None
-
-            monitor_db = database.MonitorDatabase()
-
-            control_value_dict = {"username": user}
-            new_value_dict = {"custom_avatar_url": profile_url}
-            try:
-                monitor_db.upsert('users', new_value_dict, control_value_dict)
-            except Exception, e:
-                logger.debug(u"Uncaught exception %s" % e)
-
-    def get_user_friendly_name(self, user=None, user_id=None):
-        if user_id:
-            monitor_db = database.MonitorDatabase()
-            query = 'select username, ' \
-                    '(CASE WHEN friendly_name IS NULL THEN username ELSE friendly_name END),' \
-                    'do_notify, keep_history, custom_avatar_url as thumb ' \
-                    'FROM users WHERE user_id = ?'
-            result = monitor_db.select(query, args=[user_id])
-            if result:
-                user_detail = {'user_id': user_id,
-                               'user': result[0][0],
-                               'friendly_name': result[0][1],
-                               'thumb': result[0][4],
-                               'do_notify': helpers.checked(result[0][2]),
-                               'keep_history': helpers.checked(result[0][3])
-                               }
-                return user_detail
-            else:
-                user_detail = {'user_id': user_id,
-                               'user': '',
-                               'friendly_name': '',
-                               'do_notify': '',
-                               'thumb': '',
-                               'keep_history': ''}
-                return user_detail
-        elif user:
-            monitor_db = database.MonitorDatabase()
-            query = 'select user_id, ' \
-                    '(CASE WHEN friendly_name IS NULL THEN username ELSE friendly_name END),' \
-                    'do_notify, keep_history, custom_avatar_url as thumb  ' \
-                    'FROM users WHERE username = ?'
-            result = monitor_db.select(query, args=[user])
-            if result:
-                user_detail = {'user_id': result[0][0],
-                               'user': user,
-                               'friendly_name': result[0][1],
-                               'thumb': result[0][4],
-                               'do_notify': helpers.checked(result[0][2]),
-                               'keep_history': helpers.checked(result[0][3])}
-                return user_detail
-            else:
-                user_detail = {'user_id': None,
-                               'user': user,
-                               'friendly_name': '',
-                               'do_notify': '',
-                               'thumb': '',
-                               'keep_history': ''}
-                return user_detail
-
-        return None
-
-    def get_user_id(self, user=None):
-        if user:
-            try:
-                monitor_db = database.MonitorDatabase()
-                query = 'select user_id FROM users WHERE username = ?'
-                result = monitor_db.select_single(query, args=[user])
-                if result:
-                    return result
-                else:
-                    return None
-            except:
-                return None
-
-        return None
-
-    def get_user_details(self, user=None, user_id=None):
-        from plexpy import plextv
-
-        monitor_db = database.MonitorDatabase()
-
-        if user:
-            query = 'SELECT user_id, username, friendly_name, email, ' \
-                    'custom_avatar_url as thumb, is_home_user, is_allow_sync, is_restricted, do_notify ' \
-                    'FROM users ' \
-                    'WHERE username = ? ' \
-                    'UNION ALL ' \
-                    'SELECT null, user, null, null, null, null, null, null, null ' \
-                    'FROM session_history ' \
-                    'WHERE user = ? ' \
-                    'GROUP BY user ' \
-                    'LIMIT 1'
-            result = monitor_db.select(query, args=[user, user])
-        elif user_id:
-            query = 'SELECT user_id, username, friendly_name, email, ' \
-                    'custom_avatar_url as thumb, is_home_user, is_allow_sync, is_restricted, do_notify ' \
-                    'FROM users ' \
-                    'WHERE user_id = ? ' \
-                    'UNION ALL ' \
-                    'SELECT user_id, user, null, null, null, null, null, null, null ' \
-                    'FROM session_history ' \
-                    'WHERE user_id = ? ' \
-                    'GROUP BY user ' \
-                    'LIMIT 1'
-            result = monitor_db.select(query, args=[user_id, user_id])
-        else:
-            result = None
-
-        if result:
-            user_details = {}
-            for item in result:
-                if not item['friendly_name']:
-                    friendly_name = item['username']
-                else:
-                    friendly_name = item['friendly_name']
-                if not item['thumb'] or item['thumb'] == '':
-                    user_thumb = common.DEFAULT_USER_THUMB
-                else:
-                    user_thumb = item['thumb']
-
-                user_details = {"user_id": item['user_id'],
-                                "username": item['username'],
-                                "friendly_name": friendly_name,
-                                "email": item['email'],
-                                "thumb": user_thumb,
-                                "is_home_user": item['is_home_user'],
-                                "is_allow_sync": item['is_allow_sync'],
-                                "is_restricted": item['is_restricted'],
-                                "do_notify": item['do_notify']
-                                }
-            return user_details
-        else:
-            logger.warn(u"PlexPy :: Unable to retrieve user from local database. Requesting user list refresh.")
-            # Let's first refresh the user list to make sure the user isn't newly added and not in the db yet
-            if user:
-                # Refresh users
-                plextv.refresh_users()
-                query = 'SELECT user_id, username, friendly_name, email, ' \
-                        'custom_avatar_url as thumb, is_home_user, is_allow_sync, is_restricted, do_notify ' \
-                        'FROM users ' \
-                        'WHERE username = ? ' \
-                        'UNION ALL ' \
-                        'SELECT null, user, null, null, null, null, null, null, null ' \
-                        'FROM session_history ' \
-                        'WHERE user = ? ' \
-                        'GROUP BY user ' \
-                        'LIMIT 1'
-                result = monitor_db.select(query, args=[user, user])
-            elif user_id:
-                # Refresh users
-                plextv.refresh_users()
-                query = 'SELECT user_id, username, friendly_name, email, ' \
-                        'custom_avatar_url as thumb, is_home_user, is_allow_sync, is_restricted, do_notify ' \
-                        'FROM users ' \
-                        'WHERE user_id = ? ' \
-                        'UNION ALL ' \
-                        'SELECT user_id, user, null, null, null, null, null, null, null ' \
-                        'FROM session_history ' \
-                        'WHERE user_id = ? ' \
-                        'GROUP BY user ' \
-                        'LIMIT 1'
-                result = monitor_db.select(query, args=[user_id, user_id])
-            else:
-                result = None
-
-            if result:
-                user_details = {}
-                for item in result:
-                    if not item['friendly_name']:
-                        friendly_name = item['username']
-                    else:
-                        friendly_name = item['friendly_name']
-                    if not item['thumb'] or item['thumb'] == '':
-                        user_thumb = common.DEFAULT_USER_THUMB
-                    else:
-                        user_thumb = item['thumb']
-
-                    user_details = {"user_id": item['user_id'],
-                                    "username": item['username'],
-                                    "friendly_name": friendly_name,
-                                    "email": item['email'],
-                                    "thumb": user_thumb,
-                                    "is_home_user": item['is_home_user'],
-                                    "is_allow_sync": item['is_allow_sync'],
-                                    "is_restricted": item['is_restricted'],
-                                    "do_notify": item['do_notify']
-                                    }
-                return user_details
-            else:
-                # If there is no user data we must return something
-                # Use "Local" user to retain compatibility with PlexWatch database value
-                return {"user_id": None,
-                        "username": 'Local',
-                        "friendly_name": 'Local',
-                        "email": '',
-                        "thumb": '',
-                        "is_home_user": 0,
-                        "is_allow_sync": 0,
-                        "is_restricted": 0,
-                        "do_notify": 0
-                        }
-
     def get_home_stats(self, time_range='30'):
         monitor_db = database.MonitorDatabase()
 
@@ -781,91 +425,6 @@ class DataFactory(object):
 
         return recently_watched
 
-    def get_user_watch_time_stats(self, user=None, user_id=None):
-        monitor_db = database.MonitorDatabase()
-
-        time_queries = [1, 7, 30, 0]
-        user_watch_time_stats = []
-
-        for days in time_queries:
-            if days > 0:
-                if user_id:
-                    query = 'SELECT (SUM(stopped - started) - ' \
-                            'SUM(CASE WHEN paused_counter is null THEN 0 ELSE paused_counter END)) as total_time, ' \
-                            'COUNT(id) AS total_plays ' \
-                            'FROM session_history ' \
-                            'WHERE datetime(stopped, "unixepoch", "localtime") >= datetime("now", "-%s days", "localtime") ' \
-                            'AND user_id = ?' % days
-                    result = monitor_db.select(query, args=[user_id])
-                elif user:
-                    query = 'SELECT (SUM(stopped - started) - ' \
-                            'SUM(CASE WHEN paused_counter is null THEN 0 ELSE paused_counter END)) as total_time, ' \
-                            'COUNT(id) AS total_plays ' \
-                            'FROM session_history ' \
-                            'WHERE datetime(stopped, "unixepoch", "localtime") >= datetime("now", "-%s days", "localtime") ' \
-                            'AND user = ?' % days
-                    result = monitor_db.select(query, args=[user])
-            else:
-                query = 'SELECT (SUM(stopped - started) - ' \
-                        'SUM(CASE WHEN paused_counter is null THEN 0 ELSE paused_counter END)) as total_time, ' \
-                        'COUNT(id) AS total_plays ' \
-                        'FROM session_history ' \
-                        'WHERE user = ?'
-                result = monitor_db.select(query, args=[user])
-
-            for item in result:
-                if item[0]:
-                    total_time = item[0]
-                    total_plays = item[1]
-                else:
-                    total_time = 0
-                    total_plays = 0
-
-                row = {'query_days': days,
-                       'total_time': total_time,
-                       'total_plays': total_plays
-                       }
-
-                user_watch_time_stats.append(row)
-
-        return user_watch_time_stats
-
-    def get_user_platform_stats(self, user=None, user_id=None):
-        monitor_db = database.MonitorDatabase()
-
-        platform_stats = []
-        result_id = 0
-
-        try:
-            if user_id:
-                query = 'SELECT player, COUNT(player) as player_count, platform ' \
-                        'FROM session_history ' \
-                        'WHERE user_id = ? ' \
-                        'GROUP BY player ' \
-                        'ORDER BY player_count DESC'
-                result = monitor_db.select(query, args=[user_id])
-            else:
-                query = 'SELECT player, COUNT(player) as player_count, platform ' \
-                        'FROM session_history ' \
-                        'WHERE user = ? ' \
-                        'GROUP BY player ' \
-                        'ORDER BY player_count DESC'
-                result = monitor_db.select(query, args=[user])
-        except:
-            logger.warn("Unable to execute database query.")
-            return None
-
-        for item in result:
-            row = {'platform_name': item[0],
-                   'platform_type': item[2],
-                   'total_plays': item[1],
-                   'result_id': result_id
-                   }
-            platform_stats.append(row)
-            result_id += 1
-
-        return platform_stats
-
     def get_metadata_details(self, row_id):
         monitor_db = database.MonitorDatabase()
 
diff --git a/plexpy/monitor.py b/plexpy/monitor.py
index 1d93fa74..74695bb8 100644
--- a/plexpy/monitor.py
+++ b/plexpy/monitor.py
@@ -231,10 +231,10 @@ class MonitorProcessing(object):
             self.db.upsert('sessions', timestamp, keys)
 
     def write_session_history(self, session=None, import_metadata=None, is_import=False, import_ignore_interval=0):
-        from plexpy import datafactory
+        from plexpy import users
 
-        data_factory = datafactory.DataFactory()
-        user_details = data_factory.get_user_friendly_name(user=session['user'])
+        user_data = users.Users()
+        user_details = user_data.get_user_friendly_name(user=session['user'])
 
         if session:
             logging_enabled = False
diff --git a/plexpy/notification_handler.py b/plexpy/notification_handler.py
index 0a15026c..2cef7abd 100644
--- a/plexpy/notification_handler.py
+++ b/plexpy/notification_handler.py
@@ -20,12 +20,12 @@ import time
 
 
 def notify(stream_data=None, notify_action=None):
-    from plexpy import datafactory
+    from plexpy import users
     
     if stream_data and notify_action:
         # Check if notifications enabled for user
-        data_factory = datafactory.DataFactory()
-        user_details = data_factory.get_user_friendly_name(user=stream_data['user'])
+        user_data = users.Users()
+        user_details = user_data.get_user_friendly_name(user=stream_data['user'])
 
         if not user_details['do_notify']:
             return
diff --git a/plexpy/plextv.py b/plexpy/plextv.py
index 8ca98957..b952004b 100644
--- a/plexpy/plextv.py
+++ b/plexpy/plextv.py
@@ -13,7 +13,7 @@
 #  You should have received a copy of the GNU General Public License
 #  along with PlexPy.  If not, see <http://www.gnu.org/licenses/>.
 
-from plexpy import logger, helpers, datafactory, http_handler, database
+from plexpy import logger, helpers, users, http_handler, database
 
 from xml.dom import minidom
 
@@ -38,13 +38,16 @@ def refresh_users():
                               }
 
             # Check if we've set a custom avatar if so don't overwrite it.
-            avatar_urls = monitor_db.select('SELECT thumb, custom_avatar_url '
-                                            'FROM users WHERE user_id = ?',
-                                            [item['user_id']])
-
-            if not avatar_urls[0]['custom_avatar_url'] or \
-                    avatar_urls[0]['custom_avatar_url'] == avatar_urls[0]['thumb']:
-                new_value_dict['custom_avatar_url'] = item['thumb']
+            if item['user_id']:
+                avatar_urls = monitor_db.select('SELECT thumb, custom_avatar_url '
+                                                'FROM users WHERE user_id = ?',
+                                                [item['user_id']])
+                if avatar_urls:
+                    if not avatar_urls[0]['custom_avatar_url'] or \
+                            avatar_urls[0]['custom_avatar_url'] == avatar_urls[0]['thumb']:
+                        new_value_dict['custom_avatar_url'] = item['thumb']
+                else:
+                    new_value_dict['custom_avatar_url'] = item['thumb']
 
             monitor_db.upsert('users', new_value_dict, control_value_dict)
 
@@ -253,7 +256,7 @@ class PlexTV(object):
 
     def get_synced_items(self, machine_id=None, user_id=None):
         sync_list = self.get_plextv_sync_lists(machine_id)
-        data_factory = datafactory.DataFactory()
+        user_data = users.Users()
 
         synced_items = []
 
@@ -277,8 +280,8 @@ class PlexTV(object):
                 for device in sync_device:
                     device_user_id = helpers.get_xml_attr(device, 'userID')
                     try:
-                        device_username = data_factory.get_user_details(user_id=device_user_id)['username']
-                        device_friendly_name = data_factory.get_user_details(user_id=device_user_id)['friendly_name']
+                        device_username = user_data.get_user_details(user_id=device_user_id)['username']
+                        device_friendly_name = user_data.get_user_details(user_id=device_user_id)['friendly_name']
                     except:
                         device_username = ''
                         device_friendly_name = ''
diff --git a/plexpy/plexwatch_import.py b/plexpy/plexwatch_import.py
index c37a8893..f567ce33 100644
--- a/plexpy/plexwatch_import.py
+++ b/plexpy/plexwatch_import.py
@@ -15,7 +15,7 @@
 
 import sqlite3
 
-from plexpy import logger, helpers, monitor, datafactory, plextv
+from plexpy import logger, helpers, monitor, users, plextv
 from xml.dom import minidom
 
 import plexpy
@@ -246,7 +246,7 @@ def import_from_plexwatch(database=None, table_name=None, import_ignore_interval
     plexpy.schedule_job(monitor.check_active_sessions, 'Check for active sessions', hours=0, minutes=0, seconds=0)
 
     monitor_processing = monitor.MonitorProcessing()
-    data_factory = datafactory.DataFactory()
+    user_data = users.Users()
 
     # Get the latest friends list so we can pull user id's
     try:
@@ -292,8 +292,8 @@ def import_from_plexwatch(database=None, table_name=None, import_ignore_interval
             continue
 
         # If the user_id no longer exists in the friends list, pull it from the xml.
-        if data_factory.get_user_id(user=row['user']):
-            user_id = data_factory.get_user_id(user=row['user'])
+        if user_data.get_user_id(user=row['user']):
+            user_id = user_data.get_user_id(user=row['user'])
         else:
             user_id = extracted_xml['user_id']
 
diff --git a/plexpy/pmsconnect.py b/plexpy/pmsconnect.py
index c7f794f4..54d2093f 100644
--- a/plexpy/pmsconnect.py
+++ b/plexpy/pmsconnect.py
@@ -13,7 +13,7 @@
 #  You should have received a copy of the GNU General Public License
 #  along with PlexPy.  If not, see <http://www.gnu.org/licenses/>.
 
-from plexpy import logger, helpers, datafactory, http_handler
+from plexpy import logger, helpers, users, http_handler
 from urlparse import urlparse
 
 import plexpy
@@ -507,7 +507,7 @@ class PmsConnect(object):
     """
     def get_session_each(self, stream_type='', session=None):
         session_output = None
-        data_factory = datafactory.DataFactory()
+        user_data = users.Users()
         if stream_type == 'track':
 
             media_info = session.getElementsByTagName('Media')[0]
@@ -533,7 +533,7 @@ class PmsConnect(object):
                 transcode_container = ''
                 transcode_protocol = ''
 
-            user_details = data_factory.get_user_details(
+            user_details = user_data.get_user_details(
                 user=helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title'))
 
             if helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'machineIdentifier').endswith('_Track'):
@@ -641,7 +641,7 @@ class PmsConnect(object):
             else:
                 use_indexes = 0
 
-            user_details = data_factory.get_user_details(
+            user_details = user_data.get_user_details(
                 user=helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title'))
 
             if helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'machineIdentifier').endswith('_Video'):
diff --git a/plexpy/users.py b/plexpy/users.py
new file mode 100644
index 00000000..fcc9cf94
--- /dev/null
+++ b/plexpy/users.py
@@ -0,0 +1,463 @@
+# This file is part of PlexPy.
+#
+#  PlexPy is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  PlexPy is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with PlexPy.  If not, see <http://www.gnu.org/licenses/>.
+
+from plexpy import logger, datatables, common, database, helpers
+
+
+class Users(object):
+
+    def __init__(self):
+        pass
+
+    def get_user_list(self, kwargs=None):
+        data_tables = datatables.DataTables()
+
+        columns = ['users.user_id as user_id',
+                   'users.custom_avatar_url as thumb',
+                   '(case when users.friendly_name is null then users.username else \
+                    users.friendly_name end) as friendly_name',
+                   'MAX(session_history.started) as last_seen',
+                   'session_history.ip_address as ip_address',
+                   'COUNT(session_history.id) as plays',
+                   'users.username as user'
+                   ]
+        try:
+            query = data_tables.ssp_query(table_name='users',
+                                          columns=columns,
+                                          custom_where=[],
+                                          group_by=['users.user_id'],
+                                          join_types=['LEFT OUTER JOIN'],
+                                          join_tables=['session_history'],
+                                          join_evals=[['session_history.user_id', 'users.user_id']],
+                                          kwargs=kwargs)
+        except:
+            logger.warn("Unable to execute database query.")
+            return {'recordsFiltered': 0,
+                    'recordsTotal': 0,
+                    'draw': 0,
+                    'data': 'null',
+                    'error': 'Unable to execute database query.'}
+
+        users = query['result']
+
+        rows = []
+        for item in users:
+            if not item['thumb'] or item['thumb'] == '':
+                user_thumb = common.DEFAULT_USER_THUMB
+            else:
+                user_thumb = item['thumb']
+
+            row = {"plays": item['plays'],
+                   "last_seen": item['last_seen'],
+                   "friendly_name": item["friendly_name"],
+                   "ip_address": item["ip_address"],
+                   "thumb": user_thumb,
+                   "user": item["user"],
+                   "user_id": item['user_id']
+                   }
+
+            rows.append(row)
+
+        dict = {'recordsFiltered': query['filteredCount'],
+                'recordsTotal': query['totalCount'],
+                'data': rows,
+                'draw': query['draw']
+        }
+
+        return dict
+
+    def get_user_unique_ips(self, kwargs=None, custom_where=None):
+        data_tables = datatables.DataTables()
+
+        columns = ['session_history.started as last_seen',
+                   'session_history.ip_address as ip_address',
+                   'COUNT(session_history.id) as play_count',
+                   'session_history.player as platform',
+                   'session_history_metadata.full_title as last_watched',
+                   'session_history.user as user',
+                   'session_history.user_id as user_id'
+                   ]
+
+        try:
+            query = data_tables.ssp_query(table_name='session_history',
+                                          columns=columns,
+                                          custom_where=custom_where,
+                                          group_by=['ip_address'],
+                                          join_types=['JOIN'],
+                                          join_tables=['session_history_metadata'],
+                                          join_evals=[['session_history.id', 'session_history_metadata.id']],
+                                          kwargs=kwargs)
+        except:
+            logger.warn("Unable to execute database query.")
+            return {'recordsFiltered': 0,
+                    'recordsTotal': 0,
+                    'draw': 0,
+                    'data': 'null',
+                    'error': 'Unable to execute database query.'}
+
+        results = query['result']
+
+        rows = []
+        for item in results:
+            row = {"last_seen": item['last_seen'],
+                   "ip_address": item['ip_address'],
+                   "play_count": item['play_count'],
+                   "platform": item['platform'],
+                   "last_watched": item['last_watched']
+                   }
+
+            rows.append(row)
+
+        dict = {'recordsFiltered': query['filteredCount'],
+                'recordsTotal': query['totalCount'],
+                'data': rows,
+                'draw': query['draw']
+        }
+
+        return dict
+
+    # TODO: The getter and setter for this needs to become a config getter/setter for more than just friendlyname
+    def set_user_friendly_name(self, user=None, user_id=None, friendly_name=None, do_notify=0, keep_history=1):
+        if user_id:
+            if friendly_name.strip() == '':
+                friendly_name = None
+
+            monitor_db = database.MonitorDatabase()
+
+            control_value_dict = {"user_id": user_id}
+            new_value_dict = {"friendly_name": friendly_name,
+                              "do_notify": do_notify,
+                              "keep_history": keep_history}
+            try:
+                monitor_db.upsert('users', new_value_dict, control_value_dict)
+            except Exception, e:
+                logger.debug(u"Uncaught exception %s" % e)
+        if user:
+            if friendly_name.strip() == '':
+                friendly_name = None
+
+            monitor_db = database.MonitorDatabase()
+
+            control_value_dict = {"username": user}
+            new_value_dict = {"friendly_name": friendly_name,
+                              "do_notify": do_notify,
+                              "keep_history": keep_history}
+            try:
+                monitor_db.upsert('users', new_value_dict, control_value_dict)
+            except Exception, e:
+                logger.debug(u"Uncaught exception %s" % e)
+
+    def set_user_profile_url(self, user=None, user_id=None, profile_url=None):
+        if user_id:
+            if profile_url.strip() == '':
+                profile_url = None
+
+            monitor_db = database.MonitorDatabase()
+
+            control_value_dict = {"user_id": user_id}
+            new_value_dict = {"custom_avatar_url": profile_url}
+            try:
+                monitor_db.upsert('users', new_value_dict, control_value_dict)
+            except Exception, e:
+                logger.debug(u"Uncaught exception %s" % e)
+        if user:
+            if profile_url.strip() == '':
+                profile_url = None
+
+            monitor_db = database.MonitorDatabase()
+
+            control_value_dict = {"username": user}
+            new_value_dict = {"custom_avatar_url": profile_url}
+            try:
+                monitor_db.upsert('users', new_value_dict, control_value_dict)
+            except Exception, e:
+                logger.debug(u"Uncaught exception %s" % e)
+
+    def get_user_friendly_name(self, user=None, user_id=None):
+        if user_id:
+            monitor_db = database.MonitorDatabase()
+            query = 'select username, ' \
+                    '(CASE WHEN friendly_name IS NULL THEN username ELSE friendly_name END),' \
+                    'do_notify, keep_history, custom_avatar_url as thumb ' \
+                    'FROM users WHERE user_id = ?'
+            result = monitor_db.select(query, args=[user_id])
+            if result:
+                user_detail = {'user_id': user_id,
+                               'user': result[0][0],
+                               'friendly_name': result[0][1],
+                               'thumb': result[0][4],
+                               'do_notify': helpers.checked(result[0][2]),
+                               'keep_history': helpers.checked(result[0][3])
+                               }
+                return user_detail
+            else:
+                user_detail = {'user_id': user_id,
+                               'user': '',
+                               'friendly_name': '',
+                               'do_notify': '',
+                               'thumb': '',
+                               'keep_history': ''}
+                return user_detail
+        elif user:
+            monitor_db = database.MonitorDatabase()
+            query = 'select user_id, ' \
+                    '(CASE WHEN friendly_name IS NULL THEN username ELSE friendly_name END),' \
+                    'do_notify, keep_history, custom_avatar_url as thumb  ' \
+                    'FROM users WHERE username = ?'
+            result = monitor_db.select(query, args=[user])
+            if result:
+                user_detail = {'user_id': result[0][0],
+                               'user': user,
+                               'friendly_name': result[0][1],
+                               'thumb': result[0][4],
+                               'do_notify': helpers.checked(result[0][2]),
+                               'keep_history': helpers.checked(result[0][3])}
+                return user_detail
+            else:
+                user_detail = {'user_id': None,
+                               'user': user,
+                               'friendly_name': '',
+                               'do_notify': '',
+                               'thumb': '',
+                               'keep_history': ''}
+                return user_detail
+
+        return None
+
+    def get_user_id(self, user=None):
+        if user:
+            try:
+                monitor_db = database.MonitorDatabase()
+                query = 'select user_id FROM users WHERE username = ?'
+                result = monitor_db.select_single(query, args=[user])
+                if result:
+                    return result
+                else:
+                    return None
+            except:
+                return None
+
+        return None
+
+    def get_user_details(self, user=None, user_id=None):
+        from plexpy import plextv
+
+        monitor_db = database.MonitorDatabase()
+
+        if user:
+            query = 'SELECT user_id, username, friendly_name, email, ' \
+                    'custom_avatar_url as thumb, is_home_user, is_allow_sync, is_restricted, do_notify ' \
+                    'FROM users ' \
+                    'WHERE username = ? ' \
+                    'UNION ALL ' \
+                    'SELECT null, user, null, null, null, null, null, null, null ' \
+                    'FROM session_history ' \
+                    'WHERE user = ? ' \
+                    'GROUP BY user ' \
+                    'LIMIT 1'
+            result = monitor_db.select(query, args=[user, user])
+        elif user_id:
+            query = 'SELECT user_id, username, friendly_name, email, ' \
+                    'custom_avatar_url as thumb, is_home_user, is_allow_sync, is_restricted, do_notify ' \
+                    'FROM users ' \
+                    'WHERE user_id = ? ' \
+                    'UNION ALL ' \
+                    'SELECT user_id, user, null, null, null, null, null, null, null ' \
+                    'FROM session_history ' \
+                    'WHERE user_id = ? ' \
+                    'GROUP BY user ' \
+                    'LIMIT 1'
+            result = monitor_db.select(query, args=[user_id, user_id])
+        else:
+            result = None
+
+        if result:
+            user_details = {}
+            for item in result:
+                if not item['friendly_name']:
+                    friendly_name = item['username']
+                else:
+                    friendly_name = item['friendly_name']
+                if not item['thumb'] or item['thumb'] == '':
+                    user_thumb = common.DEFAULT_USER_THUMB
+                else:
+                    user_thumb = item['thumb']
+
+                user_details = {"user_id": item['user_id'],
+                                "username": item['username'],
+                                "friendly_name": friendly_name,
+                                "email": item['email'],
+                                "thumb": user_thumb,
+                                "is_home_user": item['is_home_user'],
+                                "is_allow_sync": item['is_allow_sync'],
+                                "is_restricted": item['is_restricted'],
+                                "do_notify": item['do_notify']
+                                }
+            return user_details
+        else:
+            logger.warn(u"PlexPy :: Unable to retrieve user from local database. Requesting user list refresh.")
+            # Let's first refresh the user list to make sure the user isn't newly added and not in the db yet
+            if user:
+                # Refresh users
+                plextv.refresh_users()
+                query = 'SELECT user_id, username, friendly_name, email, ' \
+                        'custom_avatar_url as thumb, is_home_user, is_allow_sync, is_restricted, do_notify ' \
+                        'FROM users ' \
+                        'WHERE username = ? ' \
+                        'UNION ALL ' \
+                        'SELECT null, user, null, null, null, null, null, null, null ' \
+                        'FROM session_history ' \
+                        'WHERE user = ? ' \
+                        'GROUP BY user ' \
+                        'LIMIT 1'
+                result = monitor_db.select(query, args=[user, user])
+            elif user_id:
+                # Refresh users
+                plextv.refresh_users()
+                query = 'SELECT user_id, username, friendly_name, email, ' \
+                        'custom_avatar_url as thumb, is_home_user, is_allow_sync, is_restricted, do_notify ' \
+                        'FROM users ' \
+                        'WHERE user_id = ? ' \
+                        'UNION ALL ' \
+                        'SELECT user_id, user, null, null, null, null, null, null, null ' \
+                        'FROM session_history ' \
+                        'WHERE user_id = ? ' \
+                        'GROUP BY user ' \
+                        'LIMIT 1'
+                result = monitor_db.select(query, args=[user_id, user_id])
+            else:
+                result = None
+
+            if result:
+                user_details = {}
+                for item in result:
+                    if not item['friendly_name']:
+                        friendly_name = item['username']
+                    else:
+                        friendly_name = item['friendly_name']
+                    if not item['thumb'] or item['thumb'] == '':
+                        user_thumb = common.DEFAULT_USER_THUMB
+                    else:
+                        user_thumb = item['thumb']
+
+                    user_details = {"user_id": item['user_id'],
+                                    "username": item['username'],
+                                    "friendly_name": friendly_name,
+                                    "email": item['email'],
+                                    "thumb": user_thumb,
+                                    "is_home_user": item['is_home_user'],
+                                    "is_allow_sync": item['is_allow_sync'],
+                                    "is_restricted": item['is_restricted'],
+                                    "do_notify": item['do_notify']
+                                    }
+                return user_details
+            else:
+                # If there is no user data we must return something
+                # Use "Local" user to retain compatibility with PlexWatch database value
+                return {"user_id": None,
+                        "username": 'Local',
+                        "friendly_name": 'Local',
+                        "email": '',
+                        "thumb": '',
+                        "is_home_user": 0,
+                        "is_allow_sync": 0,
+                        "is_restricted": 0,
+                        "do_notify": 0
+                        }
+
+    def get_user_watch_time_stats(self, user=None, user_id=None):
+        monitor_db = database.MonitorDatabase()
+
+        time_queries = [1, 7, 30, 0]
+        user_watch_time_stats = []
+
+        for days in time_queries:
+            if days > 0:
+                if user_id:
+                    query = 'SELECT (SUM(stopped - started) - ' \
+                            'SUM(CASE WHEN paused_counter is null THEN 0 ELSE paused_counter END)) as total_time, ' \
+                            'COUNT(id) AS total_plays ' \
+                            'FROM session_history ' \
+                            'WHERE datetime(stopped, "unixepoch", "localtime") >= datetime("now", "-%s days", "localtime") ' \
+                            'AND user_id = ?' % days
+                    result = monitor_db.select(query, args=[user_id])
+                elif user:
+                    query = 'SELECT (SUM(stopped - started) - ' \
+                            'SUM(CASE WHEN paused_counter is null THEN 0 ELSE paused_counter END)) as total_time, ' \
+                            'COUNT(id) AS total_plays ' \
+                            'FROM session_history ' \
+                            'WHERE datetime(stopped, "unixepoch", "localtime") >= datetime("now", "-%s days", "localtime") ' \
+                            'AND user = ?' % days
+                    result = monitor_db.select(query, args=[user])
+            else:
+                query = 'SELECT (SUM(stopped - started) - ' \
+                        'SUM(CASE WHEN paused_counter is null THEN 0 ELSE paused_counter END)) as total_time, ' \
+                        'COUNT(id) AS total_plays ' \
+                        'FROM session_history ' \
+                        'WHERE user = ?'
+                result = monitor_db.select(query, args=[user])
+
+            for item in result:
+                if item[0]:
+                    total_time = item[0]
+                    total_plays = item[1]
+                else:
+                    total_time = 0
+                    total_plays = 0
+
+                row = {'query_days': days,
+                       'total_time': total_time,
+                       'total_plays': total_plays
+                       }
+
+                user_watch_time_stats.append(row)
+
+        return user_watch_time_stats
+
+    def get_user_platform_stats(self, user=None, user_id=None):
+        monitor_db = database.MonitorDatabase()
+
+        platform_stats = []
+        result_id = 0
+
+        try:
+            if user_id:
+                query = 'SELECT player, COUNT(player) as player_count, platform ' \
+                        'FROM session_history ' \
+                        'WHERE user_id = ? ' \
+                        'GROUP BY player ' \
+                        'ORDER BY player_count DESC'
+                result = monitor_db.select(query, args=[user_id])
+            else:
+                query = 'SELECT player, COUNT(player) as player_count, platform ' \
+                        'FROM session_history ' \
+                        'WHERE user = ? ' \
+                        'GROUP BY player ' \
+                        'ORDER BY player_count DESC'
+                result = monitor_db.select(query, args=[user])
+        except:
+            logger.warn("Unable to execute database query.")
+            return None
+
+        for item in result:
+            row = {'platform_name': item[0],
+                   'platform_type': item[2],
+                   'total_plays': item[1],
+                   'result_id': result_id
+                   }
+            platform_stats.append(row)
+            result_id += 1
+
+        return platform_stats
\ No newline at end of file
diff --git a/plexpy/webserve.py b/plexpy/webserve.py
index 9555f5e4..79eb5db3 100644
--- a/plexpy/webserve.py
+++ b/plexpy/webserve.py
@@ -13,7 +13,7 @@
 #  You should have received a copy of the GNU General Public License
 #  along with PlexPy.  If not, see <http://www.gnu.org/licenses/>.
 
-from plexpy import logger, notifiers, plextv, pmsconnect, common, log_reader, datafactory, graphs
+from plexpy import logger, notifiers, plextv, pmsconnect, common, log_reader, datafactory, graphs, users
 from plexpy.helpers import checked, radio
 
 from mako.lookup import TemplateLookup
@@ -142,16 +142,15 @@ class WebInterface(object):
 
     @cherrypy.expose
     def user(self, user=None, user_id=None):
+        user_data = users.Users()
         if user_id:
             try:
-                data_factory = datafactory.DataFactory()
-                user_details = data_factory.get_user_details(user_id=user_id)
+                user_details = user_data.get_user_details(user_id=user_id)
             except:
                 logger.warn("Unable to retrieve friendly name for user_id %s " % user_id)
         elif user:
             try:
-                data_factory = datafactory.DataFactory()
-                user_details = data_factory.get_user_details(user=user)
+                user_details = user_data.get_user_details(user=user)
             except:
                 logger.warn("Unable to retrieve friendly name for user %s " % user)
         else:
@@ -162,13 +161,12 @@ class WebInterface(object):
 
     @cherrypy.expose
     def edit_user_dialog(self, user=None, user_id=None, **kwargs):
+        user_data = users.Users()
         if user_id:
-            data_factory = datafactory.DataFactory()
-            result = data_factory.get_user_friendly_name(user_id=user_id)
+            result = user_data.get_user_friendly_name(user_id=user_id)
             status_message = ''
         elif user:
-            data_factory = datafactory.DataFactory()
-            result = data_factory.get_user_friendly_name(user=user)
+            result = user_data.get_user_friendly_name(user=user)
             status_message = ''
         else:
             result = None
@@ -191,15 +189,15 @@ class WebInterface(object):
         else:
             custom_avatar = ''
 
+        user_data = users.Users()
         if user_id:
             try:
-                data_factory = datafactory.DataFactory()
-                data_factory.set_user_friendly_name(user_id=user_id,
-                                                    friendly_name=friendly_name,
-                                                    do_notify=do_notify,
-                                                    keep_history=keep_history)
-                data_factory.set_user_profile_url(user_id=user_id,
-                                                  profile_url=custom_avatar)
+                user_data.set_user_friendly_name(user_id=user_id,
+                                                 friendly_name=friendly_name,
+                                                 do_notify=do_notify,
+                                                 keep_history=keep_history)
+                user_data.set_user_profile_url(user_id=user_id,
+                                               profile_url=custom_avatar)
 
                 status_message = "Successfully updated user."
                 return status_message
@@ -208,13 +206,12 @@ class WebInterface(object):
                 return status_message
         if user:
             try:
-                data_factory = datafactory.DataFactory()
-                data_factory.set_user_friendly_name(user=user,
-                                                    friendly_name=friendly_name,
-                                                    do_notify=do_notify,
-                                                    keep_history=keep_history)
-                data_factory.set_user_profile_url(user=user,
-                                                  profile_url=custom_avatar)
+                user_data.set_user_friendly_name(user=user,
+                                                 friendly_name=friendly_name,
+                                                 do_notify=do_notify,
+                                                 keep_history=keep_history)
+                user_data.set_user_profile_url(user=user,
+                                               profile_url=custom_avatar)
 
                 status_message = "Successfully updated user."
                 return status_message
@@ -244,11 +241,11 @@ class WebInterface(object):
     @cherrypy.expose
     def get_user_list(self, **kwargs):
 
-        data_factory = datafactory.DataFactory()
-        users = data_factory.get_user_list(kwargs=kwargs)
+        user_data = users.Users()
+        user_list = user_data.get_user_list(kwargs=kwargs)
 
         cherrypy.response.headers['Content-type'] = 'application/json'
-        return json.dumps(users)
+        return json.dumps(user_list)
 
     @cherrypy.expose
     def checkGithub(self):
@@ -763,8 +760,8 @@ class WebInterface(object):
     @cherrypy.expose
     def get_user_watch_time_stats(self, user=None, user_id=None, **kwargs):
 
-        data_factory = datafactory.DataFactory()
-        result = data_factory.get_user_watch_time_stats(user_id=user_id, user=user)
+        user_data = users.Users()
+        result = user_data.get_user_watch_time_stats(user_id=user_id, user=user)
 
         if result:
             return serve_template(templatename="user_watch_time_stats.html", data=result, title="Watch Stats")
@@ -775,8 +772,8 @@ class WebInterface(object):
     @cherrypy.expose
     def get_user_platform_stats(self, user=None, user_id=None, **kwargs):
 
-        data_factory = datafactory.DataFactory()
-        result = data_factory.get_user_platform_stats(user_id=user_id, user=user)
+        user_data = users.Users()
+        result = user_data.get_user_platform_stats(user_id=user_id, user=user)
 
         if result:
             return serve_template(templatename="user_platform_stats.html", data=result,
@@ -854,9 +851,9 @@ class WebInterface(object):
         elif user:
             custom_where = [['user', user]]
 
-        data_factory = datafactory.DataFactory()
-        history = data_factory.get_user_unique_ips(kwargs=kwargs,
-                                                   custom_where=custom_where)
+        user_data = users.Users()
+        history = user_data.get_user_unique_ips(kwargs=kwargs,
+                                                custom_where=custom_where)
 
         cherrypy.response.headers['Content-type'] = 'application/json'
         return json.dumps(history)