commit daa90739e4e25fe2a350075be70272e15ef19f89 · dunkirk.sh/smokie

+2 -2

src/features/takes/handlers/stop.ts

···

       58
        
       					elements: [

     

       59
        
       						{

     

       60
        
       							type: "mrkdwn",

     

       61
       -
       							text: `*Duration:* ${prettyPrintTime(elapsed)} ${notes ? `\n*Notes:* ${notes}` : ""}`,

     

       62
        
       						},

     

       63
        
       					],

     

       64
        
       				},

     
···

       111
        
       					elements: [

     

       112
        
       						{

     

       113
        
       							type: "mrkdwn",

     

       114
       -
       							text: `*Duration:* ${prettyPrintTime(elapsed)} ${notes ? `\n*Notes:* ${notes}` : ""}`,

     

       115
        
       						},

     

       116
        
       					],

     

       117
        
       				},

···

       58
        
       					elements: [

     

       59
        
       						{

     

       60
        
       							type: "mrkdwn",

     

       61
       +
       							text: `*Elapsed Time:* \`${prettyPrintTime(elapsed)}\`${pausedTakeToStop.description ? ` working on: *${pausedTakeToStop.description}*` : ""}`,

     

       62
        
       						},

     

       63
        
       					],

     

       64
        
       				},

     
···

       111
        
       					elements: [

     

       112
        
       						{

     

       113
        
       							type: "mrkdwn",

     

       114
       +
       							text: `\`${prettyPrintTime(elapsed)}\`${activeTakeToStop.description ? ` Working on: *${activeTakeToStop.description}*` : ""}`,

     

       115
        
       						},

     

       116
        
       					],

     

       117
        
       				},

+49 -6

src/features/takes/services/notifications.ts

···

       8
        
       	getPausedDuration,

     

       9
        
       	getRemainingTime,

     

       10
        
       } from "../../../libs/time-periods";

     

       0
        
       
     

       11
        
       

     

       12
        
       // Check for paused sessions that have exceeded the max pause duration

     

       13
        
       export async function expirePausedSessions() {

     
···

       52
        
       			}

     

       53
        
       		}

     

       54
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       55
        
       		// Auto-expire paused sessions that exceed the max pause duration

     

       56
        
       		if (pausedDuration > TakesConfig.MAX_PAUSE_DURATION) {

     

       57
        
       			let ts: string | undefined;

     
···

       60
        
       				const res = await slackApp.client.chat.postMessage({

     

       61
        
       					channel: take.userId,

     

       62
        
       					text: `⏰ Your paused takes session has been automatically completed because it was paused for more than ${TakesConfig.MAX_PAUSE_DURATION} minutes.\n\nPlease upload your takes video in this thread within the next 24 hours!`,

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       63
        
       				});

     

       64
        
       				ts = res.ts;

     

       65
        
       			} catch (error) {

     
···

       68
        
       					error,

     

       69
        
       				);

     

       70
        
       			}

     

       71
       -
       

     

       72
       -
       			// Calculate elapsed time

     

       73
       -
       			const elapsedTime = calculateElapsedTime(JSON.parse(take.periods));

     

       74
        
       

     

       75
        
       			await db

     

       76
        
       				.update(takesTable)

     
···

       123
        
       			}

     

       124
        
       		}

     

       125
        
       

     

       0
        
       
     

       0
        
       
     

       126
        
       		if (endTime.remaining <= 0) {

     

       127
        
       			let ts: string | undefined;

     

       128
        
       			try {

     

       129
        
       				const res = await slackApp.client.chat.postMessage({

     

       130
        
       					channel: take.userId,

     

       131
        
       					text: "⏰ Your takes session has automatically completed because the time is up. Please upload your takes video in this thread within the next 24 hours!",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       132
        
       				});

     

       133
        
       

     

       134
        
       				ts = res.ts;

     
···

       139
        
       				);

     

       140
        
       			}

     

       141
        
       

     

       142
       -
       			const elapsedTime = calculateElapsedTime(JSON.parse(take.periods));

     

       143
       -
       

     

       144
        
       			await db

     

       145
        
       				.update(takesTable)

     

       146
        
       				.set({

     

       147
        
       					status: "waitingUpload",

     

       148
        
       					completedAt: now,

     

       149
       -
       					elapsedTimeMs: take.targetDurationMs,

     

       150
        
       					ts,

     

       151
        
       					notes: take.notes

     

       152
        
       						? `${take.notes} (Automatically completed - time expired)`

···

       8
        
       	getPausedDuration,

     

       9
        
       	getRemainingTime,

     

       10
        
       } from "../../../libs/time-periods";

     

       11
       +
       import { prettyPrintTime } from "../../../libs/time";

     

       12
        
       

     

       13
        
       // Check for paused sessions that have exceeded the max pause duration

     

       14
        
       export async function expirePausedSessions() {

     
···

       53
        
       			}

     

       54
        
       		}

     

       55
        
       

     

       56
       +
       		// Calculate elapsed time

     

       57
       +
       		const elapsedTime = calculateElapsedTime(JSON.parse(take.periods));

     

       58
       +
       

     

       59
        
       		// Auto-expire paused sessions that exceed the max pause duration

     

       60
        
       		if (pausedDuration > TakesConfig.MAX_PAUSE_DURATION) {

     

       61
        
       			let ts: string | undefined;

     
···

       64
        
       				const res = await slackApp.client.chat.postMessage({

     

       65
        
       					channel: take.userId,

     

       66
        
       					text: `⏰ Your paused takes session has been automatically completed because it was paused for more than ${TakesConfig.MAX_PAUSE_DURATION} minutes.\n\nPlease upload your takes video in this thread within the next 24 hours!`,

     

       67
       +
       					blocks: [

     

       68
       +
       						{

     

       69
       +
       							type: "section",

     

       70
       +
       							text: {

     

       71
       +
       								type: "mrkdwn",

     

       72
       +
       								text: `⏰ Your paused takes session has been automatically completed because it was paused for more than ${TakesConfig.MAX_PAUSE_DURATION} minutes.\n\nPlease upload your takes video in this thread within the next 24 hours!`,

     

       73
       +
       							},

     

       74
       +
       						},

     

       75
       +
       						{

     

       76
       +
       							type: "divider",

     

       77
       +
       						},

     

       78
       +
       						{

     

       79
       +
       							type: "context",

     

       80
       +
       							elements: [

     

       81
       +
       								{

     

       82
       +
       									type: "mrkdwn",

     

       83
       +
       									text: `\`${prettyPrintTime(elapsedTime)}\`${take.description ? ` working on: *${take.description}*` : ""}`,

     

       84
       +
       								},

     

       85
       +
       							],

     

       86
       +
       						},

     

       87
       +
       					],

     

       88
        
       				});

     

       89
        
       				ts = res.ts;

     

       90
        
       			} catch (error) {

     
···

       93
        
       					error,

     

       94
        
       				);

     

       95
        
       			}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       96
        
       

     

       97
        
       			await db

     

       98
        
       				.update(takesTable)

     
···

       145
        
       			}

     

       146
        
       		}

     

       147
        
       

     

       148
       +
       		const elapsedTime = calculateElapsedTime(JSON.parse(take.periods));

     

       149
       +
       

     

       150
        
       		if (endTime.remaining <= 0) {

     

       151
        
       			let ts: string | undefined;

     

       152
        
       			try {

     

       153
        
       				const res = await slackApp.client.chat.postMessage({

     

       154
        
       					channel: take.userId,

     

       155
        
       					text: "⏰ Your takes session has automatically completed because the time is up. Please upload your takes video in this thread within the next 24 hours!",

     

       156
       +
       					blocks: [

     

       157
       +
       						{

     

       158
       +
       							type: "section",

     

       159
       +
       							text: {

     

       160
       +
       								type: "mrkdwn",

     

       161
       +
       								text: "⏰ Your takes session has automatically completed because the time is up. Please upload your takes video in this thread within the next 24 hours!",

     

       162
       +
       							},

     

       163
       +
       						},

     

       164
       +
       						{

     

       165
       +
       							type: "divider",

     

       166
       +
       						},

     

       167
       +
       						{

     

       168
       +
       							type: "context",

     

       169
       +
       							elements: [

     

       170
       +
       								{

     

       171
       +
       									type: "mrkdwn",

     

       172
       +
       									text: `\`${prettyPrintTime(elapsedTime)}\`${take.description ? ` working on: *${take.description}*` : ""}`,

     

       173
       +
       								},

     

       174
       +
       							],

     

       175
       +
       						},

     

       176
       +
       					],

     

       177
        
       				});

     

       178
        
       

     

       179
        
       				ts = res.ts;

     
···

       184
        
       				);

     

       185
        
       			}

     

       186
        
       

     

       0
        
       
     

       0
        
       
     

       187
        
       			await db

     

       188
        
       				.update(takesTable)

     

       189
        
       				.set({

     

       190
        
       					status: "waitingUpload",

     

       191
        
       					completedAt: now,

     

       192
       +
       					elapsedTimeMs: elapsedTime,

     

       193
        
       					ts,

     

       194
        
       					notes: take.notes

     

       195
        
       						? `${take.notes} (Automatically completed - time expired)`

+7 -10

src/features/takes/services/upload.ts

···

       76
        
       				name: "fire",

     

       77
        
       			});

     

       78
        
       

     

       79
       -
       			const takeDuration = calculateElapsedTime(JSON.parse(take.periods));

     

       80
       -
       

     

       81
        
       			await slackClient.chat.postMessage({

     

       82
        
       				channel: payload.channel,

     

       83
        
       				thread_ts: payload.thread_ts,

     
···

       98
        
       						elements: [

     

       99
        
       							{

     

       100
        
       								type: "mrkdwn",

     

       101
       -
       								text: `take by <@${user}> for \`${prettyPrintTime(takeDuration)}\` working on: *${take.description}*`,

     

       102
        
       							},

     

       103
        
       						],

     

       104
        
       					},

     
···

       113
        
       						type: "section",

     

       114
        
       						text: {

     

       115
        
       							type: "mrkdwn",

     

       116
       -
       							text: `:video_camera: new take uploaded by <@${user}> for \`${prettyPrintTime(takeDuration)}\` working on: *${take.description}*`,

     

       117
        
       						},

     

       118
        
       					},

     

       119
        
       					{

     
···

       218
        
       						elements: [

     

       219
        
       							{

     

       220
        
       								type: "mrkdwn",

     

       221
       -
       								text: `take by <@${user}> for \`${prettyPrintTime(takeDuration)}\` working on: *${take.description}*`,

     

       222
        
       							},

     

       223
        
       						],

     

       224
        
       					},

     
···

       244
        
       		if (take.length === 0) {

     

       245
        
       			return;

     

       246
        
       		}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       247
        
       		await db

     

       248
        
       			.update(takesTable)

     

       249
        
       			.set({

     
···

       252
        
       			})

     

       253
        
       			.where(eq(takesTable.id, takeId));

     

       254
        
       

     

       255
       -
       		const takeDuration = calculateElapsedTime(

     

       256
       -
       			JSON.parse(take[0]?.periods as string),

     

       257
       -
       		);

     

       258
       -
       

     

       259
        
       		await slackClient.chat.postMessage({

     

       260
        
       			channel: payload.user.id,

     

       261
        
       			thread_ts: take[0]?.ts as string,

     

       262
       -
       			text: `take approved with multiplier \`${multiplier}\` so you have earned *${Number((takeDuration * Number(multiplier)) / 60).toFixed(1)} takes*!`,

     

       263
        
       		});

     

       264
        
       

     

       265
        
       		// delete the message from the review channel

···

       76
        
       				name: "fire",

     

       77
        
       			});

     

       78
        
       

     

       0
        
       
     

       0
        
       
     

       79
        
       			await slackClient.chat.postMessage({

     

       80
        
       				channel: payload.channel,

     

       81
        
       				thread_ts: payload.thread_ts,

     
···

       96
        
       						elements: [

     

       97
        
       							{

     

       98
        
       								type: "mrkdwn",

     

       99
       +
       								text: `take by <@${user}> for \`${prettyPrintTime(take.elapsedTimeMs)}\` working on: *${take.description}*`,

     

       100
        
       							},

     

       101
        
       						],

     

       102
        
       					},

     
···

       111
        
       						type: "section",

     

       112
        
       						text: {

     

       113
        
       							type: "mrkdwn",

     

       114
       +
       							text: `:video_camera: new take uploaded by <@${user}> for \`${prettyPrintTime(take.elapsedTimeMs)}\` working on: *${take.description}*`,

     

       115
        
       						},

     

       116
        
       					},

     

       117
        
       					{

     
···

       216
        
       						elements: [

     

       217
        
       							{

     

       218
        
       								type: "mrkdwn",

     

       219
       +
       								text: `take by <@${user}> for \`${prettyPrintTime(take.elapsedTimeMs)}\` working on: *${take.description}*`,

     

       220
        
       							},

     

       221
        
       						],

     

       222
        
       					},

     
···

       242
        
       		if (take.length === 0) {

     

       243
        
       			return;

     

       244
        
       		}

     

       245
       +
       		const takeToApprove = take[0];

     

       246
       +
       		if (!takeToApprove) return;

     

       247
       +
       

     

       248
        
       		await db

     

       249
        
       			.update(takesTable)

     

       250
        
       			.set({

     
···

       253
        
       			})

     

       254
        
       			.where(eq(takesTable.id, takeId));

     

       255
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       256
        
       		await slackClient.chat.postMessage({

     

       257
        
       			channel: payload.user.id,

     

       258
        
       			thread_ts: take[0]?.ts as string,

     

       259
       +
       			text: `take approved with multiplier \`${multiplier}\` so you have earned *${Number((takeToApprove.elapsedTimeMs * Number(multiplier)) / 60).toFixed(1)} takes*!`,

     

       260
        
       		});

     

       261
        
       

     

       262
        
       		// delete the message from the review channel