Use existing feed function

daemon.py

@@ -9284,7 +9284,8 @@ class PubServer(BaseHTTPRequestHandler):
         """
         following = \
             getFollowingFeed(baseDir, domain, port, path,
-                             httpPrefix, authorized, followsPerPage)
+                             httpPrefix, authorized, followsPerPage,
+                             'following')
         if following:
             if self._requestHTTP():
                 pageNumber = 1
@@ -10277,65 +10278,17 @@ class PubServer(BaseHTTPRequestHandler):
     def _getFollowingPage(self, baseDir: str, path: str,
                           callingDomain: str,
                           httpPrefix: str,
-                          domain: str, domainFull: str,
+                          domain: str, port: int,
                           followingItemsPerPage: int,
                           debug: bool, listName='following') -> None:
         """Returns json collection for following.txt
         """
-        nickname = path.split('/users/')[1]
-        if '/' in nickname:
-            nickname = nickname.split('/')[0]
-        pageNumberStr = path.split('?page=')[1]
-        if '?' in pageNumberStr:
-            pageNumberStr = pageNumberStr.split('?')[0]
-        followingFilename = \
-            baseDir + '/accounts/' + \
-            nickname + '@' + domain + '/' + listName + '.txt'
-        if not os.path.isfile(followingFilename):
+        followingJson = \
+            getFollowingFeed(baseDir, domain, port, path, httpPrefix,
+                             True, followingItemsPerPage)
+        if not followingJson:
             self._404()
             return
-        if debug:
-            print('Getting ' + listName + ' list json for ' + nickname +
-                  ' page ' + pageNumberStr)
-        followingList = []
-        with open(followingFilename, 'r') as fp:
-            followingList = fp.readlines()
-
-        objectUrl = \
-            httpPrefix + '://' + domainFull + '/users/' + nickname + \
-            '/' + listName + '?page=' + pageNumberStr
-        followingJson = {
-            "@context": "https://www.w3.org/ns/activitystreams",
-            'id': objectUrl,
-            'type': 'Collection',
-            "totalItems": 0,
-            'items': []
-        }
-
-        if not pageNumberStr.isdigit():
-            pageNumber = 1
-        else:
-            pageNumber = int(pageNumberStr)
-        page = 1
-        ctr = 0
-        for handle in followingList:
-            ctr += 1
-            if ctr >= followingItemsPerPage:
-                ctr = 0
-                page += 1
-                if page > pageNumber:
-                    break
-            if page < pageNumber:
-                continue
-            if '://' in handle:
-                handleNickname = getNicknameFromActor(handle)
-                handleDomain, handlePort = getDomainFromActor(handle)
-                handle = handleNickname + '@' + handleDomain
-            followingJson['items'].append({
-                'type': 'Document',
-                'name': handle
-            })
-        followingJson['totalItems'] = len(followingJson['items'])
         msg = json.dumps(followingJson,
                          ensure_ascii=False).encode('utf-8')
         msglen = len(msg)
@@ -10647,7 +10600,7 @@ class PubServer(BaseHTTPRequestHandler):
                                        callingDomain,
                                        self.server.httpPrefix,
                                        self.server.domain,
-                                       self.server.domainFull,
+                                       self.server.port,
                                        self.server.followingItemsPerPage,
                                        self.server.debug, 'following')
                 return
@@ -10657,7 +10610,7 @@ class PubServer(BaseHTTPRequestHandler):
                                        callingDomain,
                                        self.server.httpPrefix,
                                        self.server.domain,
-                                       self.server.domainFull,
+                                       self.server.port,
                                        self.server.followingItemsPerPage,
                                        self.server.debug, 'followers')
                 return

epicyon.py

@@ -46,6 +46,7 @@ from filters import addFilter
 from filters import removeFilter
 from pprint import pprint
 from daemon import runDaemon
+from follow import getFollowingViaServer
 from follow import clearFollows
 from follow import followerOfPerson
 from follow import sendFollowRequestViaServer
@@ -248,6 +249,12 @@ parser.add_argument('--rss', dest='rss', type=str, default=None,
                     help='Show an rss feed for a given url')
 parser.add_argument('-f', '--federate', nargs='+', dest='federationList',
                     help='Specify federation list separated by spaces')
+parser.add_argument("--following", "--following",
+                    dest='following',
+                    type=str2bool, nargs='?',
+                    const=True, default=True,
+                    help="Get the following list. Use nickname and " +
+                    "domain options to specify the account")
 parser.add_argument("--repliesEnabled", "--commentsEnabled",
                     dest='commentsEnabled',
                     type=str2bool, nargs='?',
@@ -1484,6 +1491,34 @@ if args.unfollow:
     print('Ok')
     sys.exit()
 
+if args.following:
+    # following list via c2s protocol
+    if not args.nickname:
+        print('Please specify the nickname for the account with --nickname')
+        sys.exit()
+    if not args.password:
+        args.password = getpass.getpass('Password: ')
+        if not args.password:
+            print('Specify a password with the --password option')
+            sys.exit()
+    args.password = args.password.replace('\n', '')
+
+    session = createSession(proxyType)
+    personCache = {}
+    cachedWebfingers = {}
+    followHttpPrefix = httpPrefix
+
+    followingJson = \
+        getFollowingViaServer(baseDir, session,
+                              args.nickname, args.password,
+                              domain, port,
+                              httpPrefix, args.pageNumber,
+                              cachedWebfingers, personCache,
+                              debug, __version__)
+    if followingJson:
+        pprint(followingJson)
+    sys.exit()
+
 nickname = 'admin'
 if args.domain:
     domain = args.domain

follow.py

@@ -26,6 +26,7 @@ from acceptreject import createAccept
 from acceptreject import createReject
 from webfinger import webfingerHandle
 from auth import createBasicAuthHeader
+from session import getJson
 from session import postJson
 
 
@@ -1131,6 +1132,81 @@ def sendUnfollowRequestViaServer(baseDir: str, session,
     return unfollowJson
 
 
+def getFollowingViaServer(baseDir: str, session,
+                          nickname: str, password: str,
+                          domain: str, port: int,
+                          httpPrefix: str, pageNumber: int,
+                          cachedWebfingers: {}, personCache: {},
+                          debug: bool, projectVersion: str) -> {}:
+    """Gets a page from the following collection as json
+    """
+    if not session:
+        print('WARN: No session for getFollowingViaServer')
+        return 6
+
+    domainFull = getFullDomain(domain, port)
+
+    followActor = httpPrefix + '://' + domainFull + '/users/' + nickname
+    handle = httpPrefix + '://' + domainFull + '/@' + nickname
+
+    # lookup the inbox for the To handle
+    wfRequest = \
+        webfingerHandle(session, handle, httpPrefix, cachedWebfingers,
+                        domain, projectVersion, debug)
+    if not wfRequest:
+        if debug:
+            print('DEBUG: following list webfinger failed for ' + handle)
+        return 1
+    if not isinstance(wfRequest, dict):
+        print('WARN: following list Webfinger for ' + handle +
+              ' did not return a dict. ' + str(wfRequest))
+        return 1
+
+    postToBox = 'outbox'
+
+    # get the actor inbox for the To handle
+    (inboxUrl, pubKeyId, pubKey,
+     fromPersonId, sharedInbox, avatarUrl,
+     displayName) = getPersonBox(baseDir, session, wfRequest, personCache,
+                                 projectVersion, httpPrefix, nickname,
+                                 domain, postToBox, 52025)
+
+    if not inboxUrl:
+        if debug:
+            print('DEBUG: following list no ' + postToBox +
+                  ' was found for ' + handle)
+        return 3
+    if not fromPersonId:
+        if debug:
+            print('DEBUG: following list no actor was found for ' + handle)
+        return 4
+
+    authHeader = createBasicAuthHeader(nickname, password)
+
+    headers = {
+        'host': domain,
+        'Content-type': 'application/json',
+        'Authorization': authHeader
+    }
+
+    if pageNumber < 1:
+        pageNumber = 1
+    url = followActor + '/following?page=' + str(pageNumber)
+    followingJson = \
+        getJson(session, url, headers, {}, debug,
+                __version__, httpPrefix,
+                domain, 10, True)
+    if not followingJson:
+        if debug:
+            print('DEBUG: GET following list failed for c2s to ' + url)
+        return 5
+
+    if debug:
+        print('DEBUG: c2s GET following list request success')
+
+    return followingJson
+
+
 def getFollowersOfActor(baseDir: str, actor: str, debug: bool) -> {}:
     """In a shared inbox if we receive a post we know who it's from
     and if it's addressed to followers then we need to get a list of those.