Editing the schedule

packages/api-client/lib/openapi/api.ts

@@ -8431,6 +8431,69 @@ export const TasksApiAxiosParamCreator = function (configuration?: Configuration
         ...options.headers,
       };
 
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions,
+      };
+    },
+    /**
+     *
+     * @summary Update Schedule Task
+     * @param {number} taskId
+     * @param {PostScheduledTaskRequest} postScheduledTaskRequest
+     * @param {string} [exceptDate]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    updateScheduleTaskScheduledTasksTaskIdUpdatePost: async (
+      taskId: number,
+      postScheduledTaskRequest: PostScheduledTaskRequest,
+      exceptDate?: string,
+      options: AxiosRequestConfig = {},
+    ): Promise<RequestArgs> => {
+      // verify required parameter 'taskId' is not null or undefined
+      assertParamExists('updateScheduleTaskScheduledTasksTaskIdUpdatePost', 'taskId', taskId);
+      // verify required parameter 'postScheduledTaskRequest' is not null or undefined
+      assertParamExists(
+        'updateScheduleTaskScheduledTasksTaskIdUpdatePost',
+        'postScheduledTaskRequest',
+        postScheduledTaskRequest,
+      );
+      const localVarPath = `/scheduled_tasks/{task_id}/update`.replace(
+        `{${'task_id'}}`,
+        encodeURIComponent(String(taskId)),
+      );
+      // use dummy base URL string because the URL constructor only accepts absolute URLs.
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+
+      const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+      const localVarHeaderParameter = {} as any;
+      const localVarQueryParameter = {} as any;
+
+      if (exceptDate !== undefined) {
+        localVarQueryParameter['except_date'] =
+          (exceptDate as any) instanceof Date ? (exceptDate as any).toISOString() : exceptDate;
+      }
+
+      localVarHeaderParameter['Content-Type'] = 'application/json';
+
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = {
+        ...localVarHeaderParameter,
+        ...headersFromBaseOptions,
+        ...options.headers,
+      };
+      localVarRequestOptions.data = serializeDataIfNeeded(
+        postScheduledTaskRequest,
+        localVarRequestOptions,
+        configuration,
+      );
+
       return {
         url: toPathString(localVarUrlObj),
         options: localVarRequestOptions,
@@ -8891,6 +8954,35 @@ export const TasksApiFp = function (configuration?: Configuration) {
       );
       return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
     },
+    /**
+     *
+     * @summary Update Schedule Task
+     * @param {number} taskId
+     * @param {PostScheduledTaskRequest} postScheduledTaskRequest
+     * @param {string} [exceptDate]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async updateScheduleTaskScheduledTasksTaskIdUpdatePost(
+      taskId: number,
+      postScheduledTaskRequest: PostScheduledTaskRequest,
+      exceptDate?: string,
+      options?: AxiosRequestConfig,
+    ): Promise<
+      (
+        axios?: AxiosInstance,
+        basePath?: string,
+      ) => AxiosPromise<ApiServerModelsTortoiseModelsScheduledTaskScheduledTask>
+    > {
+      const localVarAxiosArgs =
+        await localVarAxiosParamCreator.updateScheduleTaskScheduledTasksTaskIdUpdatePost(
+          taskId,
+          postScheduledTaskRequest,
+          exceptDate,
+          options,
+        );
+      return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+    },
   };
 };
 
@@ -9271,6 +9363,30 @@ export const TasksApiFactory = function (
         )
         .then((request) => request(axios, basePath));
     },
+    /**
+     *
+     * @summary Update Schedule Task
+     * @param {number} taskId
+     * @param {PostScheduledTaskRequest} postScheduledTaskRequest
+     * @param {string} [exceptDate]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    updateScheduleTaskScheduledTasksTaskIdUpdatePost(
+      taskId: number,
+      postScheduledTaskRequest: PostScheduledTaskRequest,
+      exceptDate?: string,
+      options?: any,
+    ): AxiosPromise<ApiServerModelsTortoiseModelsScheduledTaskScheduledTask> {
+      return localVarFp
+        .updateScheduleTaskScheduledTasksTaskIdUpdatePost(
+          taskId,
+          postScheduledTaskRequest,
+          exceptDate,
+          options,
+        )
+        .then((request) => request(axios, basePath));
+    },
   };
 };
 
@@ -9680,4 +9796,30 @@ export class TasksApi extends BaseAPI {
       )
       .then((request) => request(this.axios, this.basePath));
   }
+
+  /**
+   *
+   * @summary Update Schedule Task
+   * @param {number} taskId
+   * @param {PostScheduledTaskRequest} postScheduledTaskRequest
+   * @param {string} [exceptDate]
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof TasksApi
+   */
+  public updateScheduleTaskScheduledTasksTaskIdUpdatePost(
+    taskId: number,
+    postScheduledTaskRequest: PostScheduledTaskRequest,
+    exceptDate?: string,
+    options?: AxiosRequestConfig,
+  ) {
+    return TasksApiFp(this.configuration)
+      .updateScheduleTaskScheduledTasksTaskIdUpdatePost(
+        taskId,
+        postScheduledTaskRequest,
+        exceptDate,
+        options,
+      )
+      .then((request) => request(this.axios, this.basePath));
+  }
 }

packages/api-client/lib/version.ts

@@ -3,6 +3,6 @@ import { version as rmfModelVer } from 'rmf-models';
 
 export const version = {
   rmfModels: rmfModelVer,
-  rmfServer: 'c8c43e395caae7ccc858008b7663d30914b2cc62',
+  rmfServer: '60cfa28fb26433cb33254ba1522fc00466fe7146',
   openapiGenerator: '6.2.1',
 };

packages/api-client/schema/index.ts

@@ -1283,6 +1283,53 @@ export default {
         },
       },
     },
+    '/scheduled_tasks/{task_id}/update': {
+      post: {
+        tags: ['Tasks'],
+        summary: 'Update Schedule Task',
+        operationId: 'update_schedule_task_scheduled_tasks__task_id__update_post',
+        parameters: [
+          {
+            required: true,
+            schema: { title: 'Task Id', type: 'integer' },
+            name: 'task_id',
+            in: 'path',
+          },
+          {
+            required: false,
+            schema: { title: 'Except Date', type: 'string', format: 'date-time' },
+            name: 'except_date',
+            in: 'query',
+          },
+        ],
+        requestBody: {
+          content: {
+            'application/json': {
+              schema: { $ref: '#/components/schemas/PostScheduledTaskRequest' },
+            },
+          },
+          required: true,
+        },
+        responses: {
+          '201': {
+            description: 'Successful Response',
+            content: {
+              'application/json': {
+                schema: {
+                  $ref: '#/components/schemas/api_server.models.tortoise_models.scheduled_task.ScheduledTask',
+                },
+              },
+            },
+          },
+          '422': {
+            description: 'Validation Error',
+            content: {
+              'application/json': { schema: { $ref: '#/components/schemas/HTTPValidationError' } },
+            },
+          },
+        },
+      },
+    },
     '/favorite_tasks': {
       get: {
         tags: ['Tasks'],

packages/api-server/api_server/routes/tasks/scheduled_tasks.py

@@ -1,5 +1,6 @@
 import asyncio
 from datetime import datetime
+from typing import Optional
 
 import schedule
 import tortoise.transactions
@@ -159,6 +160,75 @@ async def del_scheduled_tasks_event(
     await schedule_task(task, task_repo)
 
 
+@router.post(
+    "/{task_id}/update", status_code=201, response_model=ttm.ScheduledTaskPydantic
+)
+async def update_schedule_task(
+    task_id: int,
+    scheduled_task_request: PostScheduledTaskRequest,
+    except_date: Optional[datetime] = None,
+    task_repo: TaskRepository = Depends(task_repo_dep),
+):
+    try:
+        task = await get_scheduled_task(task_id)
+        if task is None:
+            raise HTTPException(404)
+
+        # If except_date; single event: that event is deleted from the previous task, and a new one is created
+        #   with the data requested in the schedule form [scheduled_task_request.schedules].
+        # Else; entire series: Task is completely deleted and another one is created
+        #   with the changes requested by the user.
+        async with tortoise.transactions.in_transaction():
+            if except_date:
+                task.except_dates.append(datetime_to_date_format(except_date))
+                await task.save()
+
+                for sche in task.schedules:
+                    schedule.clear(sche.get_id())
+
+                await schedule_task(task, task_repo)
+
+                scheduled_task = await ttm.ScheduledTask.create(
+                    task_request=scheduled_task_request.task_request.json(
+                        exclude_none=True
+                    ),
+                    created_by=task.created_by,
+                )
+                schedules = [
+                    ttm.ScheduledTaskSchedule(scheduled_task=scheduled_task, **x.dict())
+                    for x in scheduled_task_request.schedules
+                ]
+                await ttm.ScheduledTaskSchedule.bulk_create(schedules)
+
+                await schedule_task(scheduled_task, task_repo)
+            else:
+                task.update_from_dict(
+                    {
+                        "task_request": scheduled_task_request.task_request.json(
+                            exclude_none=True
+                        ),
+                        "except_dates": [],
+                    }
+                )
+
+                for sche in task.schedules:
+                    schedule.clear(sche.get_id())
+                for sche in task.schedules:
+                    await sche.delete()
+
+                await task.save()
+                schedules = [
+                    ttm.ScheduledTaskSchedule(scheduled_task=task, **x.dict())
+                    for x in scheduled_task_request.schedules
+                ]
+
+                await ttm.ScheduledTaskSchedule.bulk_create(schedules)
+
+                await schedule_task(task, task_repo)
+    except schedule.ScheduleError as e:
+        raise HTTPException(422, str(e)) from e
+
+
 @router.delete("/{task_id}")
 async def del_scheduled_tasks(task_id: int):
     async with tortoise.transactions.in_transaction():