lavva.exalushome
Version:
Library implementing communication and abstraction layers for ExalusHome system
292 lines (291 loc) • 12.5 kB
TypeScript
import { DeviceResponseType, DeviceTaskType } from "../Devices/IDevice";
import { DeviceControlFeature, IDeviceTask } from "../Devices/IDeviceTask";
import { AstronomicalClockWithOffsetArgument, DayOfWeekArgument, DeviceStateArgument, DeviceStateComparisonMethod, SimpleTimeSpanArgument, TimeArgument } from "./LeftArgumentTypes";
import { DelayTask, LockExecutionTask, NotifyTask } from "./SceneTaskTypes";
import { ConditionsTypes, DeviceStateType, HandledType, IRawSequence, ISequence, ISequenceInfo, SceneTaskTypeNum, SupportedTaskTypes } from "./Scenes";
export declare class SequenceBuilder {
protected _result: SequenceRequestData | null;
protected _tmp: SequenceRequestData;
protected _tmpTask: ControllerTaskRequestData | null;
private _service;
private _prevSeqGuid;
private _currentSeqGuid;
private _editingExistingSequence;
private _rawExistingSequenceTasks;
private _sequenceName;
private _sequenceIcon;
constructor(sequenceName?: string, sequenceIcon?: string);
/**
* Sets current (new or in edit) sequence name
* @param name name
*/
SetSequenceName(name: string): void;
/**
* Sets current (new or in edit) sequence icon
* @param icon icon
*/
SetSequenceIcon(icon: string): void;
/**
* Gets next sequence from sequence chain
*/
GetNext(): ISequence | null;
/**
* Method allows to clone builder with all sqeuence atributes and tasks.
* Function re-generate all guids in chain and reset navigation to first element.
* @returns cloned builder (new object)
*/
CloneCurrentBuilder(): SequenceBuilder;
/**
* Gets previous sequence from sequence chain
*/
GetPrevious(): ISequence | null;
/**
* Gets sequence by guid
* @param sequenceGuid sequence guid
*/
GetByGuid(sequenceGuid: string): ISequence | null;
EditCurrentSequence(sequence: IRawSequence): EditSequence;
/**
* Function creates argument of type AstronomicalClockWithOffse in the argument chain
* @param arg
* @returns function that adds argument to end of chain
*/
ArgumentAsAstronomicalClockWithOffset(arg: AstronomicalClockWithOffsetArgument, atMeetCondition: boolean, comparasion?: ConditionsTypes): AddOrEditArgument;
ArgumentAsActionWithEmptyCondition(): AddOrEditArgument;
/**
* Function creates argument of type DayOfWeekArgument in the argument chain
* @param arg
* @param atMeetCondition
* @param comparison
* @returns function that adds argument to end of chain
*/
ArgumentAsDaysOfWeek(arg: DayOfWeekArgument[], atMeetCondition: boolean, comparison?: ConditionsTypes): AddOrEditArgument;
/**
* Function creates argument of type SimpleTimeSpanArgument in the argument chain
* @param arg
* @param comparison
* @returns function that adds argument to end of chain
*/
ArgumentAsTimeSpan(arg: SimpleTimeSpanArgument, comparison?: ConditionsTypes): AddOrEditArgument;
/**
* Function creates argument of type ArgumentAsTime in the argument chain
* @param arg
* @param atMeetCondition
* @param comparison
* @returns function that adds argument to end of chain
*/
ArgumentAsTime(arg: TimeArgument, atMeetCondition: boolean, comparison?: ConditionsTypes): AddOrEditArgument;
/**
* Function creates argument of type DeviceStateArgument in the argument chain
* @param arg
* @param atMeetCondition
* @param atMeetConditionTimeout
* @param comparison
* @returns function that adds argument to end of chain
*/
ArgumentAsDeviceState(arg: DeviceStateArgument, atMeetCondition: boolean, atMeetConditionTimeout: number, comparison?: ConditionsTypes): AddOrEditArgument;
/**
* Function creates argument of type ArgumentAsSceneExecuted - this argument waits until given scene will be executed, then returns 'true' and allow to execute check rest of arguments in chain.
* @param arg
*/
ArgumentAsSceneExecuted(arg: ISequenceInfo): AddOrEditArgument;
protected GenerateDeviceStateArgument(arg: DeviceStateArgument): LeftArgumentDeviceStateRequestData;
protected MapResponseTypeToDeviceStateType(responseType: DeviceResponseType): DeviceStateType;
/**
* Function adds argument to the end of argument chain
* @returns Functions that coud create another argument, function that coud commit argument chain, current argument data.
*/
protected AddSequence(): Commit;
protected EditSequence(sequenceGuid: string): Commit;
RemoveSequenceByGuid(sequenceGuid: string): Commit;
/**
* Functions commits modifications of arguments chain
* @returns
*/
Commit(): AddOrRemoveTasks;
protected DeviceTask(task: IDeviceTask): AddOrEditTask;
private ParseDeviceTask;
protected DelayTask(delay: DelayTask): AddOrEditTask;
protected NotifyTask(notification: NotifyTask): AddOrEditTask;
protected LockExecutionTask(lockTask: LockExecutionTask): AddOrEditTask;
private AddTask;
protected EditTask(taskId: string): AddOrRemoveTasks;
protected RemoveTask(taskId: string): void;
protected MapTaskTypeToControlFeature(taskType: DeviceTaskType): DeviceControlFeature;
protected GetSupportedTaskTypesAsync(): Promise<SupportedTaskTypes[]>;
/**
* Function builds SequenceRequestData object, this obj. can be send via API to controller to modify or add sequence
* SequenceRequestData should be pass to EditSequenceAsync(sequence: SequenceRequestData) or CreateSequenceAsync(sequence: SequenceRequestData) methods in ScenesService;
* @returns
*/
protected Build(): SequenceRequestData;
private FindArgumentWithGuid;
/**
* Function returns allowed arguments for current context
*/
GetAllowedArguments(): ArgumentParams[];
/**
* Function validate entire sequence and returns validation result
* If sequence is invalid or needs to be optimized, we can fix it by TryFix() method or ignore validation by Ignore() method
*/
protected ValidateScene(): SceneValidation;
private TryFix;
}
export type EditSequence = {
GetNext: () => ISequence | null;
GetPrevious: () => ISequence | null;
GetByGuid: (sequenceGuid: string) => ISequence | null;
GetAllowedArguments: () => ArgumentParams[];
RemoveSequence: (sequenceGuid: string) => Commit;
ArgumentAsAstronomicalClockWithOffset: (arg: AstronomicalClockWithOffsetArgument, atMeetCondition: boolean, comparasion?: ConditionsTypes) => AddOrEditArgument;
ArgumentAsDaysOfWeek: (arg: DayOfWeekArgument[], atMeetCondition: boolean, comparison?: ConditionsTypes) => AddOrEditArgument;
ArgumentAsTimeSpan: (arg: SimpleTimeSpanArgument, comparison?: ConditionsTypes) => AddOrEditArgument;
ArgumentAsTime: (arg: TimeArgument, atMeetCondition: boolean, comparison?: ConditionsTypes) => AddOrEditArgument;
ArgumentAsDeviceState: (arg: DeviceStateArgument, atMeetCondition: boolean, atMeetConditionTimeout: number, comparison?: ConditionsTypes) => AddOrEditArgument;
ArgumentAsSceneExecuted: (arg: ISequenceInfo) => AddOrEditArgument;
RemoveTask: (taskGuid: string) => void;
};
export type AddOrEditArgument = {
AddArgument: () => Commit;
EditArgument: (sequenceArgumentGuid: string) => Commit;
};
export type Commit = {
SequenceData: ISequence | null;
GetNext: () => ISequence | null;
GetPrevious: () => ISequence | null;
GetByGuid: (sequenceGuid: string) => ISequence | null;
GetAllowedArguments: () => ArgumentParams[];
RemoveSequenceByGuid: (sequenceGuid: string) => Commit;
Commit: () => AddOrRemoveTasks;
ArgumentAsActionWithEmptyCondition: () => AddOrEditArgument;
ArgumentAsAstronomicalClockWithOffset: (arg: AstronomicalClockWithOffsetArgument, atMeetCondition: boolean, comparasion?: ConditionsTypes) => AddOrEditArgument;
ArgumentAsDaysOfWeek: (arg: DayOfWeekArgument[], atMeetCondition: boolean, comparison?: ConditionsTypes) => AddOrEditArgument;
ArgumentAsTimeSpan: (arg: SimpleTimeSpanArgument, comparison?: ConditionsTypes) => AddOrEditArgument;
ArgumentAsTime: (arg: TimeArgument, atMeetCondition: boolean, comparison?: ConditionsTypes) => AddOrEditArgument;
ArgumentAsDeviceState: (arg: DeviceStateArgument, atMeetCondition: boolean, atMeetConditionTimeout: number, comparison?: ConditionsTypes) => AddOrEditArgument;
ArgumentAsSceneExecuted: (arg: ISequenceInfo) => AddOrEditArgument;
};
export type AddOrRemoveTasks = {
GetSupportedTypesOfTasks: () => Promise<SupportedTaskTypes[]>;
DeviceTask: (task: IDeviceTask) => AddOrEditTask;
DelayTask: (delay: DelayTask) => AddOrEditTask;
NotifyTask: (notification: NotifyTask) => AddOrEditTask;
LockExecutionTask: (lockTask: LockExecutionTask) => AddOrEditTask;
RemoveTask: (taskId: string) => void;
ValidateScene: () => SceneValidation;
Build: () => SequenceRequestData;
BuildToISequence: () => ISequence;
};
export type SceneValidation = {
IsValid: boolean;
Errors: ValidationErrors[];
TryFix: () => AddOrRemoveTasks;
Ignore: () => AddOrRemoveTasks;
};
export declare enum ValidationErrors {
OptimizeDayOfWeekArgument = "OptimizeDayOfWeekArgument",
OptimizeAtInDayOfWeekArgument = "OptimizeAtInDayOfWeekArgument"
}
export declare class ArgumentParams {
ArgumentType: SupportedArgumentTypes;
InitialAtMeetConditionValue: boolean;
ChangableAtMeetCondition: boolean;
}
export declare enum SupportedArgumentTypes {
Unknown = "Unknown",
ArgumentAsAstronomicalClockWithOffset = "ArgumentAsAstronomicalClockWithOffset",
ArgumentAsDaysOfWeek = "ArgumentAsDaysOfWeek",
ArgumentAsTimeSpan = "ArgumentAsTimeSpan",
ArgumentAsTime = "ArgumentAsTime",
ArgumentAsDeviceState = "ArgumentAsDeviceState",
ArgumentAsSceneExecuted = "ArgumentAsSceneExecuted"
}
export type AddOrEditTask = {
AddTask: () => AddOrRemoveTasks;
EditTask: (taskGuid: string) => AddOrRemoveTasks;
TaskId: string;
};
export declare class SequenceRequestData {
Tasks: TasksRequestData;
Guid: string;
ObjectType: number;
Name: string;
Icon: string;
AtMeetCondition: boolean;
ExecuteOnce: boolean;
IsDisabled: boolean;
HandledType: HandledType;
ConditionType: ConditionsTypes;
ConditionTimeout: number;
LeftArgumentType: ArgumentTypeNum;
RightArgumentType: ArgumentTypeNum;
LeftArgument: LeftArgumentRequestData;
RightArgument: SequenceRequestData | EmptySequenceRequestData;
}
declare class EmptySequenceRequestData {
HandledType: number;
Argument: null;
}
declare class LeftArgumentRequestData {
constructor(argument: any, handledType: ArgumentTypeNum);
Argument: any;
HandledType: ArgumentTypeNum;
}
declare class LeftArgumentDeviceStateRequestData {
DeviceStateType: DeviceStateType;
Channel: number;
DeviceGuid: string;
ComparisonMethod: DeviceStateComparisonMethod;
ComparisonParams: any;
CheckedDeviceState: any;
}
declare class TasksRequestData {
ControllerTasks: ControllerTaskRequestData[];
DevicesTasks: DeviceTaskRequestData[];
}
declare class ControllerTaskRequestData {
Guid: string;
RunParallel: boolean;
TaskType: SceneTaskTypeNum;
}
declare class DeviceTaskRequestData extends ControllerTaskRequestData {
TaskType: SceneTaskTypeNum;
DeviceGuid: string;
Channel: number;
ControlFeature: DeviceControlFeature;
Data: any;
}
declare enum ArgumentTypeNum {
Null = 0,
Condition = 1,
ConditionGroup = 2,
ArgumentAsInt = 3,
ArgumentAsTimeSpan = 4,
ArgumentAsBoolean = 5,
ArgumentAsTimeout = 6,
ArgumentAsDayOfWeek = 7,
ArgumentAsDaysOfWeek = 8,
ArgumentAsAstronomicalClock = 9,
ArgumentAsTime = 10,
ArgumentAsDeviceState = 11,
ArgumentAsNumber = 12,
ArgumentAsAstronomicalClockWithOffset = 13,
ArgumentAsConditionInfo = 14
}
export declare class BadParametersScenesBuilderException extends Error {
message: string;
constructor(message: string);
}
export declare class SequenceNotFoundScenesBuilderException extends Error {
message: string;
constructor(message: string);
}
export declare class TaskNotFoundScenesBuilderException extends Error {
message: string;
constructor(message: string);
}
export declare class UnsupportedArgumentScenesBuilderException extends Error {
message: string;
constructor(message: string);
}
export {};