Add human-readable option for dates in team (#146)

Add human-readable dates to team Members and Logs commands.

Fix #143

Author: Corentin Mors

documentation/pages/business/audit-logs.mdx

@@ -70,7 +70,9 @@ date -d @1688629046919
 date -r 1688629046919
 ```
 
-## Export the logs as CSV
+## Options
+
+### Export as CSV
 
 You can export the logs as CSV using the `--csv` option.
 
@@ -81,7 +83,21 @@ dcli t logs --csv --start 0 --end now > logs.csv
 This allows you to open the logs in a spreadsheet editor like Excel or Google Sheets.
 Note that the `properties` field is kept as a JSON string in the CSV file because its content varies depending on the log type.
 
-## Logs types (default)
+### Human Readable dates
+
+You can use the `--human-readable` option to output the logs with human readable dates.
+
+```sh copy
+dcli t logs --human-readable
+```
+
+The date will be displayed in the ISO 8601 format.
+
+Note that a new key named `date_time_iso` will be added to the logs.
+
+## Logs types
+
+### Default types
 
 | Type                                           | Event message                                          |
 | ---------------------------------------------- | ------------------------------------------------------ |
@@ -125,7 +141,7 @@ Note that the `properties` field is kept as a JSON string in the CSV file becaus
 | billing_admin_added                            | Made %(name)s the billing contact                      |
 | billing_admin_removed                          | Revoked %(name)s as the billing contact                |
 
-## Logs types (sensitive)
+### Sensitive types
 
 You can turn on logging sensitive actions in the Policies section of Settings in the Admin Console. Read more about it in our [dedicated Help Center article](https://support.dashlane.com/hc/en-us/articles/4414606120210).
 

documentation/pages/business/members.mdx

@@ -20,7 +20,9 @@ You can pipe the output to `jq` to filter the results:
 dcli t members | jq '.members[] | select(.isTeamCaptain == true)'
 ```
 
-## Exporting the list as a CSV
+## Options
+
+### Exporting the list as a CSV
 
 You can use the `--csv` flag to export the list as a CSV file:
 
@@ -30,6 +32,18 @@ dcli t members --csv > members.csv
 
 This allows you to open the file in a spreadsheet editor such as Excel or Google Sheets.
 
+### Human Readable dates
+
+You can use the `--human-readable` option to output the logs with human readable dates.
+
+```sh copy
+dcli t members --human-readable
+```
+
+The dates will be displayed in the ISO 8601 format.
+
+Note that keys ending with `Unix` will be converted to human readable dates and renamed to remove the `Unix` suffix.
+
 ## Members interface
 
 | Property                                      | Type                                                                                        | Description                                      |

src/command-handlers/devices.ts

@@ -1,6 +1,6 @@
 import { connectAndPrepare, reset } from '../modules/database';
 import { deactivateDevices, listDevices, ListDevicesOutput } from '../endpoints';
-import { askConfirmReset, unixTimestampToHumanReadable } from '../utils';
+import { askConfirmReset, epochTimestampToIso } from '../utils';
 
 type OutputDevice = ListDevicesOutput['devices'][number] & {
     isCurrentDevice: boolean;
@@ -29,7 +29,7 @@ export async function listAllDevices(options: { json: boolean }) {
                 id: device.deviceId,
                 name: device.deviceName,
                 platform: device.devicePlatform,
-                lastActivity: unixTimestampToHumanReadable(device.lastActivityDateUnix),
+                lastActivity: epochTimestampToIso(device.lastActivityDateUnix),
                 current: device.isCurrentDevice,
             };
         });

src/command-handlers/teamDevices.ts

@@ -1,6 +1,6 @@
 import { connectAndPrepare } from '../modules/database';
 import { listTeamDevices } from '../endpoints';
-import { unixTimestampToHumanReadable } from '../utils';
+import { epochTimestampToIso } from '../utils';
 
 export async function listAllTeamDevices(options: { json: boolean }) {
     const { db, secrets } = await connectAndPrepare({ autoSync: false });
@@ -32,9 +32,9 @@ export async function listAllTeamDevices(options: { json: boolean }) {
                 accessKey: device.accessKey,
                 name: device.deviceName,
                 platform: device.platform,
-                creationDate: unixTimestampToHumanReadable(device.creationDateUnix),
-                updateDate: unixTimestampToHumanReadable(device.updateDateUnix),
-                lastActivityDate: unixTimestampToHumanReadable(device.lastActivityDateUnix),
+                creationDate: epochTimestampToIso(device.creationDateUnix),
+                updateDate: epochTimestampToIso(device.updateDateUnix),
+                lastActivityDate: epochTimestampToIso(device.lastActivityDateUnix),
             };
         });
 

src/command-handlers/teamLogs.ts

@@ -1,22 +1,24 @@
 import winston from 'winston';
 import { connectAndPrepare } from '../modules/database';
 import { StartAuditLogsQueryParams, startAuditLogsQuery, getAuditLogQueryResults } from '../endpoints';
-import { getTeamDeviceCredentials, jsonToCsv } from '../utils';
+import { getTeamDeviceCredentials, jsonToCsv, epochTimestampToIso } from '../utils';
+import { GenericLog } from '../types/logs';
 
 export const runTeamLogs = async (options: {
     start: string;
     end: string;
     type: string;
     category: string;
     csv: boolean;
+    humanReadable: boolean;
 }) => {
     const teamDeviceCredentials = getTeamDeviceCredentials();
 
     const { start, type, category } = options;
     const end = options.end === 'now' ? Date.now().toString() : options.end;
 
     const { db } = await connectAndPrepare({ autoSync: false });
-    const logs = await getAuditLogs({
+    let logs = await getAuditLogs({
         teamDeviceCredentials,
         startDateRangeUnix: parseInt(start),
         endDateRangeUnix: parseInt(end),
@@ -25,17 +27,26 @@ export const runTeamLogs = async (options: {
     });
     db.close();
 
+    if (options.humanReadable) {
+        logs = logs.map((log) => {
+            return {
+                ...log,
+                date_time_iso: epochTimestampToIso(log.date_time, true),
+            };
+        });
+    }
+
     if (options.csv) {
-        console.log(jsonToCsv(logs.map((log) => JSON.parse(log) as object)));
+        console.log(jsonToCsv(logs));
         return;
     }
 
-    logs.forEach((log) => console.log(log));
+    logs.forEach((log) => console.log(JSON.stringify(log)));
 };
 
 const MAX_RESULT = 1000;
 
-export const getAuditLogs = async (params: StartAuditLogsQueryParams): Promise<string[]> => {
+export const getAuditLogs = async (params: StartAuditLogsQueryParams): Promise<GenericLog[]> => {
     const { teamDeviceCredentials } = params;
 
     const { queryExecutionId } = await startAuditLogsQuery(params);
@@ -65,5 +76,5 @@ export const getAuditLogs = async (params: StartAuditLogsQueryParams): Promise<s
         logs = logs.concat(result.results);
     }
 
-    return logs;
+    return logs.map((log) => JSON.parse(log) as GenericLog);
 };

src/command-handlers/teamMembers.ts

@@ -1,10 +1,11 @@
 import { getTeamMembers as getTeamMembersRequest } from '../endpoints';
-import { getTeamDeviceCredentials, flattenJsonArrayOfObject, jsonToCsv } from '../utils';
+import { getTeamDeviceCredentials, flattenJsonArrayOfObject, jsonToCsv, epochTimestampToIso } from '../utils';
 
 interface GetTeamMembersParams {
     page: number;
     limit: number;
     csv: boolean;
+    humanReadable: boolean;
 }
 
 export const runTeamMembers = async (params: GetTeamMembersParams) => {
@@ -17,6 +18,25 @@ export const runTeamMembers = async (params: GetTeamMembersParams) => {
         limit,
     });
 
+    if (params.humanReadable) {
+        response.members = response.members.map((member) => {
+            const memberWithHumanReadableDates = {
+                ...member,
+                joinedDate: epochTimestampToIso(member.joinedDateUnix),
+                invitedDate: epochTimestampToIso(member.invitedDateUnix),
+                revokedDate: epochTimestampToIso(member.revokedDateUnix),
+                lastUpdateDate: epochTimestampToIso(member.lastUpdateDateUnix),
+            };
+
+            delete memberWithHumanReadableDates.joinedDateUnix;
+            delete memberWithHumanReadableDates.invitedDateUnix;
+            delete memberWithHumanReadableDates.revokedDateUnix;
+            delete memberWithHumanReadableDates.lastUpdateDateUnix;
+
+            return memberWithHumanReadableDates;
+        });
+    }
+
     if (params.csv) {
         if (response.pages) {
             console.log(`Page ${response.page + 1} of ${response.pages}`);

src/commands/team/index.ts

@@ -30,11 +30,13 @@ export const teamCommands = (params: { program: Command }) => {
         .argument('[page]', 'Page number', '0')
         .argument('[limit]', 'Limit of members per page', '0')
         .option('--csv', 'Output in CSV format')
-        .action(async (page: string, limit: string, options: { csv: boolean }) => {
+        .option('--human-readable', 'Output dates in human readable format')
+        .action(async (page: string, limit: string, options: { csv: boolean; humanReadable: boolean }) => {
             await runTeamMembers({
                 page: parseInt(page),
                 limit: parseInt(limit),
                 csv: options.csv,
+                humanReadable: options.humanReadable,
             });
         });
 
@@ -47,6 +49,7 @@ export const teamCommands = (params: { program: Command }) => {
         .option('--type <type>', 'log type')
         .option('--category <category>', 'log category')
         .option('--csv', 'Output in CSV format')
+        .option('--human-readable', 'Output dates in human readable format')
         .action(runTeamLogs);
 
     teamGroup

src/types/logs.ts

@@ -0,0 +1,92 @@
+export interface GenericLog {
+    schema_version: string;
+    /**
+     * The audit log's unique ID
+     */
+    uuid: string;
+    /**
+     * The team ID the user that performed the action is a member of.
+     */
+    team_id: number;
+    /**
+     * The user ID of the user that performed the action.
+     */
+    author_user_id: number;
+    /**
+     * The user ID of the user that is the target of the action.
+     */
+    target_user_id?: number;
+    /**
+     * The sharing group ID the performed action is associated with.
+     */
+    sharing_group_id?: number;
+    /**
+     * The type of the audit log. (e.g. user_device_added).
+     */
+    log_type: string;
+    /**
+     * A milliseconds timestamp of the date and time the action occurred.
+     */
+    date_time: number;
+    author_client?: {
+        /**
+         * Dashlane client version of the user that did or logged the action.
+         */
+        version?: string | null;
+        /**
+         * Dashlane client platform of the user that did or logged the action.
+         */
+        platform?: string | null;
+    };
+    /**
+     * The category the audit log type falls under.
+     */
+    category:
+        | 'account'
+        | 'authentication'
+        | 'dark_web_monitoring'
+        | 'groups'
+        | 'import_export'
+        | 'sharing'
+        | 'team_settings'
+        | 'team_settings_activedirectory'
+        | 'team_settings_policies'
+        | 'team_settings_samlprovisioning'
+        | 'team_settings_scim'
+        | 'team_settings_sso'
+        | 'user_settings'
+        | 'user_settings_accountrecovery'
+        | 'users'
+        | 'vault_ids'
+        | 'vault_passwords'
+        | 'vault_payments'
+        | 'vault_personalinfo'
+        | 'vault_securenotes';
+    /**
+     * The team device ID of the team that performed the action.
+     */
+    author_team_device_id?: number;
+    /**
+     * Whether the audit log contains sensitive data.
+     */
+    is_sensitive?: boolean;
+    properties?: {
+        [k: string]: any;
+    };
+    encrypted_properties?: {
+        [k: string]: any;
+    };
+    server_encrypted_properties?: {
+        [k: string]: any;
+    };
+    meta?: {
+        /**
+         * The encryption key used to encrypt the encrypted_properties property.
+         */
+        encrypted_properties_encryption_key_uuid?: string;
+        /**
+         * The encryption key used to encrypt the server_encrypted_properties property.
+         */
+        server_encrypted_properties_encryption_key_uuid?: string;
+    };
+}

src/utils/strings.ts

@@ -22,9 +22,22 @@ export const removeUnderscoresAndCapitalize = (string: string): string => {
         .join(' ');
 };
 
-/** Unix timestamp to human readable string */
-export const unixTimestampToHumanReadable = (timestamp: number | null): string => {
-    return timestamp ? new Date(timestamp * 1000).toLocaleString() : 'N/A';
+/** Epoch unix timestamp in seconds to ISO 8601 */
+export const epochTimestampToIso = (
+    timestamp: string | number | null | undefined,
+    inMilliseconds?: boolean
+): string => {
+    if (timestamp === null || timestamp === undefined) {
+        return '';
+    }
+
+    let timestampNumber = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
+
+    if (!inMilliseconds) {
+        timestampNumber *= 1000;
+    }
+
+    return new Date(timestampNumber).toISOString();
 };
 
 export const jsonToCsv = (json: Record<string, any>): string => {