API: torrents: remove unused props in TorrentPeer, TorrentTracker

client/src/javascript/components/modals/set-trackers-modal/SetTrackersModal.tsx

@@ -3,6 +3,8 @@ import {injectIntl, WrappedComponentProps} from 'react-intl';
 import {observable, runInAction} from 'mobx';
 import {observer} from 'mobx-react';
 
+import {TorrentTrackerType} from '@shared/types/TorrentTracker';
+
 import {Form, FormRow, Textbox} from '../../../ui';
 import Modal from '../Modal';
 import TextboxRepeater, {getTextArray} from '../../general/form-elements/TextboxRepeater';
@@ -29,10 +31,7 @@ class SetTrackersModal extends Component<WrappedComponentProps, SetTrackersModal
       if (trackers != null) {
         runInAction(() => {
           this.trackerURLs.replace(
-            trackers
-              .filter((tracker) => tracker.isEnabled)
-              .map((tracker) => tracker.url)
-              .filter((url) => url.startsWith('http') || url.startsWith('udp')),
+            trackers.filter((tracker) => tracker.type !== TorrentTrackerType.DHT).map((tracker) => tracker.url),
           );
           this.setState({isLoadingTrackers: false});
         });

client/src/javascript/components/modals/torrent-details-modal/TorrentTrackers.tsx

@@ -20,7 +20,7 @@ class TorrentTrackers extends Component<unknown> {
       TorrentActions.fetchTorrentTrackers(UIStore.activeModal?.hash).then((trackers) => {
         if (trackers != null) {
           runInAction(() => {
-            this.trackers.replace(trackers.filter((tracker) => tracker.isEnabled));
+            this.trackers.replace(trackers);
           });
         }
       });

server/services/qBittorrent/clientGatewayService.ts

@@ -1,5 +1,3 @@
-import crypto from 'crypto';
-
 import type {ClientSettings} from '@shared/types/ClientSettings';
 import type {QBittorrentConnectionSettings} from '@shared/schema/ClientConnectionSettings';
 import type {TorrentContent} from '@shared/types/TorrentContent';
@@ -120,17 +118,12 @@ class QBittorrentClientGatewayService extends ClientGatewayService {
 
           const properties = getTorrentPeerPropertiesFromFlags(peer.flags);
           accumulator.push({
-            country: peer.country_code,
             address: peer.ip,
-            completedPercent: Math.trunc(peer.progress * 100),
+            country: peer.country_code,
             clientVersion: peer.client,
+            completedPercent: Math.trunc(peer.progress * 100),
             downloadRate: peer.dl_speed,
-            downloadTotal: peer.downloaded,
             uploadRate: peer.up_speed,
-            uploadTotal: peer.uploaded,
-            id: crypto.createHash('sha1').update(ip_and_port).digest('base64'),
-            peerRate: 0,
-            peerTotal: 0,
             isEncrypted: properties.isEncrypted,
             isIncoming: properties.isIncoming,
           });
@@ -145,18 +138,14 @@ class QBittorrentClientGatewayService extends ClientGatewayService {
       .getTorrentTrackers(hash)
       .then(this.processClientRequestSuccess, this.processClientRequestError)
       .then((trackers) => {
-        return trackers.map((tracker, index) => {
-          return {
-            index,
-            id: crypto.createHash('sha1').update(tracker.url).digest('base64'),
-            url: tracker.url,
-            type: getTorrentTrackerTypeFromURL(tracker.url),
-            group: tracker.tier,
-            minInterval: 0,
-            normalInterval: 0,
-            isEnabled: tracker.status !== QBittorrentTorrentTrackerStatus.DISABLED,
-          };
-        });
+        return trackers
+          .filter((tracker) => tracker.status !== QBittorrentTorrentTrackerStatus.DISABLED)
+          .map((tracker) => {
+            return {
+              url: tracker.url,
+              type: getTorrentTrackerTypeFromURL(tracker.url),
+            };
+          });
       });
   }
 

server/services/rTorrent/clientGatewayService.ts

@@ -225,10 +225,18 @@ class RTorrentClientGatewayService extends ClientGatewayService {
         .methodCall('t.multicall', [hash, ''].concat(getMethodCalls(configs)))
         .then(this.processClientRequestSuccess, this.processClientRequestError)
         .then((responses: string[][]) => {
-          return Promise.all(
-            responses.map((response) => processMethodCallResponse(response, configs) as Promise<TorrentTracker>),
-          );
-        }) || Promise.reject()
+          return Promise.all(responses.map((response) => processMethodCallResponse(response, configs)));
+        })
+        .then((processedResponses) =>
+          processedResponses
+            .filter((processedResponse) => processedResponse.isEnabled)
+            .map((processedResponse) => {
+              return {
+                url: processedResponse.url,
+                type: processedResponse.type,
+              };
+            }),
+        ) || Promise.reject()
     );
   }
 

server/services/rTorrent/constants/methodCallConfigs/torrentPeer.ts

@@ -1,10 +1,6 @@
 import {stringTransformer, booleanTransformer, numberTransformer} from '../../util/rTorrentMethodCallUtil';
 
 const torrentPeerMethodCallConfigs = {
-  id: {
-    methodCall: 'p.id=',
-    transformValue: stringTransformer,
-  },
   address: {
     methodCall: 'p.address=',
     transformValue: stringTransformer,
@@ -21,26 +17,10 @@ const torrentPeerMethodCallConfigs = {
     methodCall: 'p.down_rate=',
     transformValue: numberTransformer,
   },
-  downloadTotal: {
-    methodCall: 'p.down_total=',
-    transformValue: numberTransformer,
-  },
   uploadRate: {
     methodCall: 'p.up_rate=',
     transformValue: numberTransformer,
   },
-  uploadTotal: {
-    methodCall: 'p.up_total=',
-    transformValue: numberTransformer,
-  },
-  peerRate: {
-    methodCall: 'p.peer_rate=',
-    transformValue: numberTransformer,
-  },
-  peerTotal: {
-    methodCall: 'p.peer_total=',
-    transformValue: numberTransformer,
-  },
   isEncrypted: {
     methodCall: 'p.is_encrypted=',
     transformValue: booleanTransformer,

server/services/rTorrent/constants/methodCallConfigs/torrentTracker.ts

@@ -1,10 +1,6 @@
 import {booleanTransformer, numberTransformer, stringTransformer} from '../../util/rTorrentMethodCallUtil';
 
 const torrentTrackerMethodCallConfigs = {
-  id: {
-    methodCall: 't.id=',
-    transformValue: stringTransformer,
-  },
   url: {
     methodCall: 't.url=',
     transformValue: stringTransformer,
@@ -13,18 +9,6 @@ const torrentTrackerMethodCallConfigs = {
     methodCall: 't.type=',
     transformValue: numberTransformer,
   },
-  group: {
-    methodCall: 't.group=',
-    transformValue: numberTransformer,
-  },
-  minInterval: {
-    methodCall: 't.min_interval=',
-    transformValue: numberTransformer,
-  },
-  normalInterval: {
-    methodCall: 't.normal_interval=',
-    transformValue: numberTransformer,
-  },
   isEnabled: {
     methodCall: 't.is_enabled=',
     transformValue: booleanTransformer,

shared/types/TorrentPeer.ts

@@ -1,15 +1,10 @@
 export interface TorrentPeer {
-  country: string;
   address: string;
-  completedPercent: number;
+  country: string;
   clientVersion: string;
+  completedPercent: number;
   downloadRate: number;
-  downloadTotal: number;
   uploadRate: number;
-  uploadTotal: number;
-  id: string;
-  peerRate: number;
-  peerTotal: number;
   isEncrypted: boolean;
   isIncoming: boolean;
 }

shared/types/TorrentTracker.ts

@@ -5,12 +5,6 @@ export enum TorrentTrackerType {
 }
 
 export interface TorrentTracker {
-  index: number;
-  id: string;
   url: string;
   type: TorrentTrackerType;
-  group: number;
-  minInterval: number;
-  normalInterval: number;
-  isEnabled: boolean;
 }