chz-telegram-bot 0.3.25 → 0.3.26

package/dist/helpers/builders/scheduledActionBuilder.d.ts

@@ -2,18 +2,19 @@ import { ScheduledAction } from '../../entities/actions/scheduledAction';
 import { ActionStateBase } from '../../entities/states/actionStateBase';
 import { IActionState } from '../../types/actionState';
 import { ScheduledHandler } from '../../types/handlers';
+import { ScheduledActionPropertyProvider } from '../../types/propertyProvider';
 import { Hours, HoursOfDay } from '../../types/timeValues';
 /**
  * Builder for `ScheduledAction` with state represented by `TActionState`
  */
 export declare class ScheduledActionBuilderWithState<TActionState extends IActionState> {
-    private active;
-    private time;
+    private readonly name;
     private readonly cachedStateFactories;
-    private whitelist;
     private readonly stateConstructor;
     private handler;
-    private readonly name;
+    private whitelistProvider;
+    private activeProvider;
+    private timeinHoursProvider;
     /**
      * Builder for `ScheduledAction` with state represented by `TActionState`
      * @param name Action name, will be used for logging and storage
@@ -44,6 +45,14 @@ export declare class ScheduledActionBuilderWithState<TActionState extends IActio
     withSharedCache(key: string, itemFactory: () => Promise<unknown>, invalidationTimeoutInHours?: Hours): this;
     /** If called during building, action is marked as disabled and never checked. */
     disabled(): this;
+    /**
+     * Configures action to use property value providers instead of static value to allow changes in runtime
+     */
+    withConfiguration(configuration: {
+        timeinHoursProvider?: ScheduledActionPropertyProvider<HoursOfDay>;
+        isActiveProvider?: ScheduledActionPropertyProvider<boolean>;
+        chatsWhitelistProvider?: ScheduledActionPropertyProvider<number[]>;
+    }): this;
     /** Builds action */
     build(): ScheduledAction<TActionState>;
 }

package/dist/helpers/builders/scheduledActionBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scheduledActionBuilder.d.ts","sourceRoot":"","sources":["../../../helpers/builders/scheduledActionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAEzE,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAG3D;;GAEG;AACH,qBAAa,+BAA+B,CACxC,YAAY,SAAS,YAAY;IAEjC,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,IAAI,CAAiB;IAC7B,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAGjC;IACJ,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAqB;IACtD,OAAO,CAAC,OAAO,CAA6C;IAE5D,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAE9B;;;;OAIG;gBACS,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,YAAY;IAK9D;;;OAGG;IACH,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE;IAMpB;;;OAGG;IACH,KAAK,CAAC,IAAI,EAAE,UAAU;IAMtB;;OAEG;IACH,EAAE,CAAC,OAAO,EAAE,gBAAgB,CAAC,YAAY,CAAC;IAM1C;;;;;;OAMG;IACH,eAAe,CACX,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EACnC,0BAA0B,GAAE,KAAmB;IAUnD,iFAAiF;IACjF,QAAQ;IAMR,oBAAoB;IACpB,KAAK;CAWR;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,+BAA+B,CAAC,eAAe,CAAC;IACxF;;OAEG;gBACS,IAAI,EAAE,MAAM;CAG3B"}
+{"version":3,"file":"scheduledActionBuilder.d.ts","sourceRoot":"","sources":["../../../helpers/builders/scheduledActionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAEzE,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,+BAA+B,EAAE,MAAM,8BAA8B,CAAC;AAC/E,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAG3D;;GAEG;AACH,qBAAa,+BAA+B,CACxC,YAAY,SAAS,YAAY;IAEjC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAGjC;IACJ,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAqB;IACtD,OAAO,CAAC,OAAO,CAA6C;IAE5D,OAAO,CAAC,iBAAiB,CACZ;IACb,OAAO,CAAC,cAAc,CACb;IACT,OAAO,CAAC,mBAAmB,CACf;IAEZ;;;;OAIG;gBACS,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,YAAY;IAK9D;;;OAGG;IACH,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE;IAMpB;;;OAGG;IACH,KAAK,CAAC,IAAI,EAAE,UAAU;IAMtB;;OAEG;IACH,EAAE,CAAC,OAAO,EAAE,gBAAgB,CAAC,YAAY,CAAC;IAM1C;;;;;;OAMG;IACH,eAAe,CACX,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EACnC,0BAA0B,GAAE,KAAmB;IAUnD,iFAAiF;IACjF,QAAQ;IAMR;;OAEG;IACH,iBAAiB,CAAC,aAAa,EAAE;QAC7B,mBAAmB,CAAC,EAAE,+BAA+B,CAAC,UAAU,CAAC,CAAC;QAClE,gBAAgB,CAAC,EAAE,+BAA+B,CAAC,OAAO,CAAC,CAAC;QAC5D,sBAAsB,CAAC,EAAE,+BAA+B,CAAC,MAAM,EAAE,CAAC,CAAC;KACtE;IAaD,oBAAoB;IACpB,KAAK;CAaR;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,+BAA+B,CAAC,eAAe,CAAC;IACxF;;OAEG;gBACS,IAAI,EAAE,MAAM;CAG3B"}

package/dist/helpers/builders/scheduledActionBuilder.js

@@ -9,13 +9,13 @@ const noop_1 = require("../noop");
  * Builder for `ScheduledAction` with state represented by `TActionState`
  */
 class ScheduledActionBuilderWithState {
-    active = true;
-    time = 0;
+    name;
     cachedStateFactories = new Map();
-    whitelist = [];
     stateConstructor;
     handler = noop_1.Noop.call;
-    name;
+    whitelistProvider = () => [];
+    activeProvider = () => true;
+    timeinHoursProvider = () => 0;
     /**
      * Builder for `ScheduledAction` with state represented by `TActionState`
      * @param name Action name, will be used for logging and storage
@@ -30,7 +30,7 @@ class ScheduledActionBuilderWithState {
      * @param chatIds Chat ids to execute in.
      */
     in(chatIds) {
-        this.whitelist = chatIds;
+        this.whitelistProvider = () => chatIds;
         return this;
     }
     /**
@@ -38,7 +38,7 @@ class ScheduledActionBuilderWithState {
      * @param time Time of day (0 - 23) to execute action.
      */
     runAt(time) {
-        this.time = time;
+        this.timeinHoursProvider = () => time;
         return this;
     }
     /** Defines action logic itself, will be executed on timer.
@@ -61,12 +61,28 @@ class ScheduledActionBuilderWithState {
     }
     /** If called during building, action is marked as disabled and never checked. */
     disabled() {
-        this.active = false;
+        this.activeProvider = () => false;
+        return this;
+    }
+    /**
+     * Configures action to use property value providers instead of static value to allow changes in runtime
+     */
+    withConfiguration(configuration) {
+        if (configuration.chatsWhitelistProvider)
+            this.whitelistProvider = configuration.chatsWhitelistProvider;
+        if (configuration.timeinHoursProvider)
+            this.timeinHoursProvider = configuration.timeinHoursProvider;
+        if (configuration.isActiveProvider)
+            this.activeProvider = configuration.isActiveProvider;
         return this;
     }
     /** Builds action */
     build() {
-        return new scheduledAction_1.ScheduledAction(this.name, this.handler, this.time, this.active, this.whitelist, this.cachedStateFactories, this.stateConstructor);
+        return new scheduledAction_1.ScheduledAction(this.name, this.handler, {
+            chatsWhitelistProvider: this.whitelistProvider,
+            isActiveProvider: this.activeProvider,
+            timeinHoursProvider: this.timeinHoursProvider
+        }, this.cachedStateFactories, this.stateConstructor);
     }
 }
 exports.ScheduledActionBuilderWithState = ScheduledActionBuilderWithState;

package/dist/types/propertyProvider.d.ts

@@ -0,0 +1,8 @@
+import { ChatContext } from '../entities/context/chatContext';
+import { InlineQueryContext } from '../entities/context/inlineQueryContext';
+import { MessageContext } from '../entities/context/messageContext';
+import { IActionState } from './actionState';
+export type CommandActionPropertyProvider<T> = (ctx: MessageContext<IActionState>) => T;
+export type InlineActionPropertyProvider<T> = (ctx: InlineQueryContext) => T;
+export type ScheduledActionPropertyProvider<T> = (ctx: ChatContext<IActionState>) => T;
+//# sourceMappingURL=propertyProvider.d.ts.map

package/dist/types/propertyProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propertyProvider.d.ts","sourceRoot":"","sources":["../../types/propertyProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,MAAM,MAAM,6BAA6B,CAAC,CAAC,IAAI,CAC3C,GAAG,EAAE,cAAc,CAAC,YAAY,CAAC,KAChC,CAAC,CAAC;AAEP,MAAM,MAAM,4BAA4B,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,kBAAkB,KAAK,CAAC,CAAC;AAE7E,MAAM,MAAM,+BAA+B,CAAC,CAAC,IAAI,CAC7C,GAAG,EAAE,WAAW,CAAC,YAAY,CAAC,KAC7B,CAAC,CAAC"}

package/dist/types/propertyProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dtos/cooldownInfo.ts

@@ -2,9 +2,9 @@ import { Seconds } from '../types/timeValues';
 
 export class CooldownInfo {
     constructor(
-        /** New one-time cooldown in seconds */
-        readonly seconds: Seconds,
+        /** Cooldown configuration */
+        readonly cooldown: Seconds,
         /** Cooldown message to be shown */
-        readonly message: string | undefined
+        readonly message?: string
     ) {}
 }

package/dtos/propertyProviderSets.ts

@@ -0,0 +1,20 @@
+import { CooldownInfo } from './cooldownInfo';
+import {
+    CommandActionPropertyProvider,
+    ScheduledActionPropertyProvider
+} from '../types/propertyProvider';
+import { HoursOfDay } from '../types/timeValues';
+
+export type CommandActionProviders = {
+    cooldownProvider: CommandActionPropertyProvider<CooldownInfo>;
+    isActiveProvider: CommandActionPropertyProvider<boolean>;
+    chatsBlacklistProvider: CommandActionPropertyProvider<number[]>;
+    chatsWhitelistProvider: CommandActionPropertyProvider<number[]>;
+    usersWhitelistProvider: CommandActionPropertyProvider<number[]>;
+};
+
+export type ScheduledActionProviders = {
+    timeinHoursProvider: ScheduledActionPropertyProvider<HoursOfDay>;
+    isActiveProvider: ScheduledActionPropertyProvider<boolean>;
+    chatsWhitelistProvider: ScheduledActionPropertyProvider<number[]>;
+};

package/entities/actions/commandAction.ts

@@ -16,26 +16,36 @@ import { CooldownInfo } from '../../dtos/cooldownInfo';
 import { TextMessage } from '../../dtos/responses/textMessage';
 import { ReplyInfo } from '../../dtos/replyInfo';
 import { Seconds } from '../../types/timeValues';
-import { ActionPermissionsData } from '../../dtos/actionPermissionsData';
+import { CommandActionPropertyProvider } from '../../types/propertyProvider';
+import { CommandActionProviders } from '../../dtos/propertyProviderSets';
+import { BotResponse } from '../../types/response';
 
 export class CommandAction<TActionState extends IActionState>
     implements IActionWithState<TActionState>
 {
+    private readonly cooldownInfoProvider: CommandActionPropertyProvider<CooldownInfo>;
+    private readonly isActiveProvider: CommandActionPropertyProvider<boolean>;
+    private readonly chatsBlacklistProvider: CommandActionPropertyProvider<
+        number[]
+    >;
+    private readonly chatsWhitelistProvider: CommandActionPropertyProvider<
+        number[]
+    >;
+    private readonly usersWhitelistProvider: CommandActionPropertyProvider<
+        number[]
+    >;
+
+    readonly key: ActionKey;
+    readonly name: string;
     readonly ratelimitSemaphores = new Map<number, Semaphore>();
+    readonly maxAllowedSimultaniousExecutions: number;
 
     readonly triggers: CommandTrigger[];
+
     readonly handler: CommandHandler<TActionState>;
-    readonly name: string;
-    readonly cooldownInfo: CooldownInfo;
-    readonly active: boolean;
-    readonly chatsBlacklist: number[];
-    readonly chatsWhitelist: number[];
-    readonly usersWhitelist: number[];
     readonly condition: CommandCondition<TActionState>;
     readonly stateConstructor: () => TActionState;
-    readonly key: ActionKey;
     readonly readmeFactory: (botName: string) => string;
-    readonly maxAllowedSimultaniousExecutions: number;
 
     private lastCustomCooldown: Seconds | undefined;
 
@@ -43,32 +53,35 @@ export class CommandAction<TActionState extends IActionState>
         trigger: CommandTrigger | CommandTrigger[],
         handler: CommandHandler<TActionState>,
         name: string,
-        active: boolean,
-        cooldownInfo: CooldownInfo,
-        permissionsData: ActionPermissionsData,
+        providers: CommandActionProviders,
         maxAllowedSimultaniousExecutions: number,
         condition: CommandCondition<TActionState>,
         stateConstructor: () => TActionState,
         readmeFactory: (botName: string) => string
     ) {
         this.triggers = toArray(trigger);
-        this.handler = handler;
         this.name = name;
-        this.cooldownInfo = cooldownInfo;
-        this.active = active;
-        this.chatsBlacklist = permissionsData.chatIdsBlacklist;
-        this.chatsWhitelist = permissionsData.chatIdsWhitelist;
-        this.usersWhitelist = permissionsData.userIdsWhitelist;
+
+        this.cooldownInfoProvider = providers.cooldownProvider;
+        this.isActiveProvider = providers.isActiveProvider;
+        this.chatsBlacklistProvider = providers.chatsBlacklistProvider;
+        this.chatsWhitelistProvider = providers.chatsWhitelistProvider;
+        this.usersWhitelistProvider = providers.usersWhitelistProvider;
+
+        this.handler = handler;
         this.condition = condition;
         this.stateConstructor = stateConstructor;
         this.readmeFactory = readmeFactory;
+
         this.maxAllowedSimultaniousExecutions =
             maxAllowedSimultaniousExecutions;
 
         this.key = `command:${this.name.replace('.', '-')}` as ActionKey;
     }
 
-    async exec(ctx: MessageContextInternal<TActionState>) {
+    async exec(
+        ctx: MessageContextInternal<TActionState>
+    ): Promise<BotResponse[]> {
         if (!ctx.isInitialized)
             throw new Error(
                 `Context for ${this.key} is not initialized or already consumed`
@@ -100,16 +113,22 @@ export class CommandAction<TActionState extends IActionState>
                     );
 
             if (!shouldExecute) {
-                if (reason == 'OnCooldown' && this.cooldownInfo.message)
-                    return [
-                        new TextMessage(
-                            this.cooldownInfo.message,
-                            ctx.chatInfo,
-                            ctx.traceId,
-                            this,
-                            new ReplyInfo(ctx.messageInfo.id)
-                        )
-                    ];
+                if (reason == 'OnCooldown') {
+                    const cooldownMessage =
+                        this.cooldownInfoProvider(ctx).message;
+
+                    return cooldownMessage
+                        ? [
+                              new TextMessage(
+                                  cooldownMessage,
+                                  ctx.chatInfo,
+                                  ctx.traceId,
+                                  this,
+                                  new ReplyInfo(ctx.messageInfo.id)
+                              )
+                          ]
+                        : Noop.NoResponse;
+                }
 
                 return Noop.NoResponse;
             }
@@ -148,15 +167,18 @@ export class CommandAction<TActionState extends IActionState>
         trigger: CommandTrigger,
         state: TActionState
     ) {
-        if (!this.active)
+        if (!this.isActiveProvider(ctx))
             return CommandTriggerCheckResult.DontTriggerAndSkipCooldown(
                 'ActionDisabled'
             );
 
-        const isChatInBlacklist = this.chatsBlacklist.includes(ctx.chatInfo.id);
+        const chatsBlacklist = this.chatsBlacklistProvider(ctx);
+        const chatsWhitelist = this.chatsWhitelistProvider(ctx);
+
+        const isChatInBlacklist = chatsBlacklist.includes(ctx.chatInfo.id);
         const isChatInWhitelist =
-            this.chatsWhitelist.length == 0 ||
-            this.chatsWhitelist.includes(ctx.chatInfo.id);
+            chatsWhitelist.length == 0 ||
+            chatsWhitelist.includes(ctx.chatInfo.id);
 
         if (isChatInBlacklist || !isChatInWhitelist)
             return CommandTriggerCheckResult.DontTriggerAndSkipCooldown(
@@ -172,9 +194,10 @@ export class CommandAction<TActionState extends IActionState>
                 'UserIdMissing'
             );
 
+        const usersWhitelist = this.usersWhitelistProvider(ctx);
         const isUserAllowed =
-            this.usersWhitelist.length == 0 ||
-            this.usersWhitelist.includes(ctx.userInfo.id);
+            usersWhitelist.length == 0 ||
+            usersWhitelist.includes(ctx.userInfo.id);
 
         if (!isUserAllowed)
             return CommandTriggerCheckResult.DontTriggerAndSkipCooldown(
@@ -183,7 +206,7 @@ export class CommandAction<TActionState extends IActionState>
 
         const lastExecutedDate = moment(state.lastExecutedDate);
         const cooldownInMilliseconds = secondsToMilliseconds(
-            this.lastCustomCooldown ?? this.cooldownInfo.seconds
+            this.lastCustomCooldown ?? this.cooldownInfoProvider(ctx).cooldown
         );
         const onCooldown =
             moment().diff(lastExecutedDate) < cooldownInMilliseconds;

package/entities/actions/inlineQueryAction.ts

@@ -2,10 +2,11 @@ import { Noop } from '../../helpers/noop';
 import { ActionKey, IAction } from '../../types/action';
 import { InlineQueryContextInternal } from '../context/inlineQueryContext';
 import { InlineQueryHandler } from '../../types/handlers';
+import { InlineActionPropertyProvider } from '../../types/propertyProvider';
 
 export class InlineQueryAction implements IAction {
     readonly key: ActionKey;
-    readonly active: boolean;
+    readonly isActiveProvider: InlineActionPropertyProvider<boolean>;
     readonly handler: InlineQueryHandler;
     readonly name: string;
     readonly pattern: RegExp;
@@ -13,12 +14,12 @@ export class InlineQueryAction implements IAction {
     constructor(
         handler: InlineQueryHandler,
         name: string,
-        active: boolean,
+        activeProvider: InlineActionPropertyProvider<boolean>,
         pattern: RegExp
     ) {
         this.handler = handler;
         this.name = name;
-        this.active = active;
+        this.isActiveProvider = activeProvider;
         this.pattern = pattern;
 
         this.key = `inline:${this.name.replace('.', '-')}` as ActionKey;
@@ -30,7 +31,7 @@ export class InlineQueryAction implements IAction {
                 `Context for ${this.key} is not initialized or already consumed`
             );
 
-        if (!this.active) return Noop.NoResponse;
+        if (!this.isActiveProvider(ctx)) return Noop.NoResponse;
 
         const matchResults: RegExpExecArray[] = [];
 

package/entities/actions/scheduledAction.ts

@@ -10,6 +10,8 @@ import { ChatContextInternal } from '../context/chatContext';
 import { Noop } from '../../helpers/noop';
 import { IScheduler } from '../../types/scheduler';
 import { getOrSetIfNotExists, getOrThrow } from '../../helpers/mapUtils';
+import { ScheduledActionPropertyProvider } from '../../types/propertyProvider';
+import { ScheduledActionProviders } from '../../dtos/propertyProviderSets';
 
 export class ScheduledAction<TActionState extends IActionState>
     implements IActionWithState<TActionState>
@@ -17,11 +19,14 @@ export class ScheduledAction<TActionState extends IActionState>
     static readonly locks = new Map<string, Semaphore>();
 
     readonly name: string;
-    readonly timeinHours: HoursOfDay;
-    readonly active: boolean;
-    readonly chatsWhitelist: number[];
     readonly key: ActionKey;
 
+    private readonly timeinHoursProvider: ScheduledActionPropertyProvider<HoursOfDay>;
+    private readonly activeProvider: ScheduledActionPropertyProvider<boolean>;
+    private readonly chatsWhitelistProvider: ScheduledActionPropertyProvider<
+        number[]
+    >;
+
     readonly cachedState = new Map<string, unknown>();
     readonly stateConstructor: () => TActionState;
     readonly cachedStateFactories: Map<string, CachedStateFactory>;
@@ -30,20 +35,20 @@ export class ScheduledAction<TActionState extends IActionState>
     constructor(
         name: string,
         handler: ScheduledHandler<TActionState>,
-        timeinHours: HoursOfDay,
-        active: boolean,
-        whitelist: number[],
+        providers: ScheduledActionProviders,
         cachedStateFactories: Map<string, CachedStateFactory>,
         stateConstructor: () => TActionState
     ) {
         this.name = name;
-        this.handler = handler;
-        this.timeinHours = timeinHours;
-        this.active = active;
-        this.chatsWhitelist = whitelist;
-        this.cachedStateFactories = cachedStateFactories;
         this.key = `scheduled:${this.name.replace('.', '-')}` as ActionKey;
+
+        this.timeinHoursProvider = providers.timeinHoursProvider;
+        this.activeProvider = providers.isActiveProvider;
+        this.chatsWhitelistProvider = providers.chatsWhitelistProvider;
+
+        this.cachedStateFactories = cachedStateFactories;
         this.stateConstructor = stateConstructor;
+        this.handler = handler;
     }
 
     async exec(ctx: ChatContextInternal<TActionState>) {
@@ -52,7 +57,10 @@ export class ScheduledAction<TActionState extends IActionState>
                 `Context for ${this.key} is not initialized or already consumed`
             );
 
-        if (!this.active || !this.chatsWhitelist.includes(ctx.chatInfo.id))
+        if (
+            !this.activeProvider(ctx) ||
+            !this.chatsWhitelistProvider(ctx).includes(ctx.chatInfo.id)
+        )
             return Noop.NoResponse;
 
         const state = await ctx.storage.getActionState<TActionState>(
@@ -60,7 +68,7 @@ export class ScheduledAction<TActionState extends IActionState>
             ctx.chatInfo.id
         );
 
-        const isAllowedToTrigger = this.checkIfShouldBeExecuted(state);
+        const isAllowedToTrigger = this.checkIfShouldBeExecuted(state, ctx);
         if (!isAllowedToTrigger) return Noop.NoResponse;
 
         ctx.logger.logWithTraceId(
@@ -129,13 +137,16 @@ export class ScheduledAction<TActionState extends IActionState>
         }
     }
 
-    private checkIfShouldBeExecuted(state: IActionState): boolean {
+    private checkIfShouldBeExecuted(
+        state: IActionState,
+        ctx: ChatContextInternal<TActionState>
+    ): boolean {
         const startOfToday = moment().startOf('day').valueOf();
         const lastExecutedDate = moment(state.lastExecutedDate);
         const currentTime = moment();
         const scheduledTime = moment()
             .startOf('day')
-            .add(this.timeinHours, 'hours');
+            .add(this.timeinHoursProvider(ctx), 'hours');
 
         const isAllowedToTrigger = currentTime.isSameOrAfter(scheduledTime);
         const hasTriggeredToday = lastExecutedDate.isAfter(startOfToday);

package/helpers/builders/commandActionBuilder.ts

@@ -8,7 +8,7 @@ import { toArray } from '../toArray';
 import { Noop } from '../noop';
 import { CommandTrigger } from '../../types/commandTrigger';
 import { CooldownInfo } from '../../dtos/cooldownInfo';
-import { ActionPermissionsData } from '../../dtos/actionPermissionsData';
+import { CommandActionPropertyProvider } from '../../types/propertyProvider';
 
 /**
  * Builder for `CommandAction` with state represented by `TActionState`
@@ -17,17 +17,21 @@ export class CommandActionBuilderWithState<TActionState extends IActionState> {
     private readonly name: string;
     private trigger: CommandTrigger | CommandTrigger[] = [];
 
-    private active = true;
-    private cooldownSeconds: Seconds = 0 as Seconds;
-    private blacklist: number[] = [];
-    private whitelist: number[] = [];
-    private allowedUsers: number[] = [];
+    private activeProvider: CommandActionPropertyProvider<boolean> = () => true;
+    private cooldownSettingsProvider: CommandActionPropertyProvider<CooldownInfo> =
+        () => new CooldownInfo(0 as Seconds);
+    private blacklistProvider: CommandActionPropertyProvider<number[]> =
+        () => [];
+    private whitelistProvider: CommandActionPropertyProvider<number[]> =
+        () => [];
+    private allowedUsersProvider: CommandActionPropertyProvider<number[]> =
+        () => [];
+
     private readmeFactory: (botName: string) => string = Noop.emptyString;
     private readonly stateConstructor: () => TActionState;
     private handler: CommandHandler<TActionState> = Noop.call;
     private condition: CommandCondition<TActionState> = Noop.true;
     private maxAllowedSimultaniousExecutions: number = 0;
-    private cooldownMessage: string | undefined;
 
     /**
      * Builder for `CommandAction` with state represented by `TActionState`
@@ -55,7 +59,8 @@ export class CommandActionBuilderWithState<TActionState extends IActionState> {
      * @param id User id or ids
      */
     from(id: number | number[]) {
-        this.allowedUsers = toArray(id);
+        const ids = toArray(id);
+        this.allowedUsersProvider = () => ids;
 
         return this;
     }
@@ -65,7 +70,7 @@ export class CommandActionBuilderWithState<TActionState extends IActionState> {
      * @param chatIds Chats ids to allow.
      */
     in(chatIds: number[]) {
-        this.whitelist = chatIds;
+        this.whitelistProvider = () => chatIds;
 
         return this;
     }
@@ -75,7 +80,7 @@ export class CommandActionBuilderWithState<TActionState extends IActionState> {
      * @param chatIds Chats ids to ignore.
      */
     notIn(chatIds: number[]) {
-        this.blacklist = chatIds;
+        this.blacklistProvider = () => chatIds;
 
         return this;
     }
@@ -110,7 +115,7 @@ export class CommandActionBuilderWithState<TActionState extends IActionState> {
 
     /** If called during building, action is marked as disabled and never checked. */
     disabled() {
-        this.active = false;
+        this.activeProvider = () => false;
 
         return this;
     }
@@ -126,9 +131,40 @@ export class CommandActionBuilderWithState<TActionState extends IActionState> {
     /** Sets action cooldown settings.
      * @param cooldownSettings Settings.
      */
-    withCooldown(cooldownSettings: { seconds: Seconds; message?: string }) {
-        this.cooldownSeconds = cooldownSettings.seconds;
-        this.cooldownMessage = cooldownSettings.message;
+    withCooldown(cooldownSettings: { cooldown: Seconds; message?: string }) {
+        const settings = new CooldownInfo(
+            cooldownSettings.cooldown,
+            cooldownSettings.message
+        );
+        this.cooldownSettingsProvider = () => settings;
+
+        return this;
+    }
+
+    /**
+     * Configures action to use property value providers instead of static value to allow changes in runtime
+     */
+    withConfiguration(configuration: {
+        cooldownProvider?: CommandActionPropertyProvider<CooldownInfo>;
+        isActiveProvider?: CommandActionPropertyProvider<boolean>;
+        chatsBlacklistProvider?: CommandActionPropertyProvider<number[]>;
+        chatsWhitelistProvider?: CommandActionPropertyProvider<number[]>;
+        usersWhitelistProvider?: CommandActionPropertyProvider<number[]>;
+    }) {
+        if (configuration.cooldownProvider)
+            this.cooldownSettingsProvider = configuration.cooldownProvider;
+
+        if (configuration.chatsWhitelistProvider)
+            this.whitelistProvider = configuration.chatsWhitelistProvider;
+
+        if (configuration.chatsBlacklistProvider)
+            this.blacklistProvider = configuration.chatsBlacklistProvider;
+
+        if (configuration.usersWhitelistProvider)
+            this.allowedUsersProvider = configuration.usersWhitelistProvider;
+
+        if (configuration.isActiveProvider)
+            this.activeProvider = configuration.isActiveProvider;
 
         return this;
     }
@@ -139,13 +175,13 @@ export class CommandActionBuilderWithState<TActionState extends IActionState> {
             this.trigger,
             this.handler,
             this.name,
-            this.active,
-            new CooldownInfo(this.cooldownSeconds, this.cooldownMessage),
-            new ActionPermissionsData(
-                this.allowedUsers,
-                this.whitelist,
-                this.blacklist
-            ),
+            {
+                cooldownProvider: this.cooldownSettingsProvider,
+                isActiveProvider: this.activeProvider,
+                chatsBlacklistProvider: this.blacklistProvider,
+                chatsWhitelistProvider: this.whitelistProvider,
+                usersWhitelistProvider: this.allowedUsersProvider
+            },
             this.maxAllowedSimultaniousExecutions,
             this.condition,
             this.stateConstructor,

package/helpers/builders/inlineQueryActionBuilder.ts

@@ -1,6 +1,7 @@
 import { InlineQueryHandler } from '../../types/handlers';
 import { Noop } from '../noop';
 import { InlineQueryAction } from '../../entities/actions/inlineQueryAction';
+import { InlineActionPropertyProvider } from '../../types/propertyProvider';
 
 /**
  * Builder for `InlineQueryAction`
@@ -9,7 +10,7 @@ export class InlineQueryActionBuilder {
     private readonly name: string;
     private pattern: RegExp = /.+/gi;
 
-    private active = true;
+    private activeProvider: InlineActionPropertyProvider<boolean> = () => true;
     private handler: InlineQueryHandler = Noop.call;
 
     /**
@@ -41,7 +42,19 @@ export class InlineQueryActionBuilder {
 
     /** If called during building, action is marked as disabled and never checked. */
     disabled() {
-        this.active = false;
+        this.activeProvider = () => false;
+
+        return this;
+    }
+
+    /**
+     * Configures action to use property value providers instead of static value to allow changes in runtime
+     */
+    withConfiguration(configuration: {
+        isActiveProvider?: InlineActionPropertyProvider<boolean>;
+    }) {
+        if (configuration.isActiveProvider)
+            this.activeProvider = configuration.isActiveProvider;
 
         return this;
     }
@@ -51,7 +64,7 @@ export class InlineQueryActionBuilder {
         return new InlineQueryAction(
             this.handler,
             this.name,
-            this.active,
+            this.activeProvider,
             this.pattern
         );
     }