From 4ed55616affcb54443b50d0fae4b00f21c136eeb Mon Sep 17 00:00:00 2001
From: Simen Fivelstad Smaaberg
 <66635118+simensma-fresh@users.noreply.github.com>
Date: Wed, 18 Sep 2024 10:11:40 -0700
Subject: [PATCH] [MDS-6118] FE extract permits - DRAFT (#3236)

* make a button on the FE call the BE. Write reducer for permit service covering basic functionality

* stub out extraction method on core-api, tweak logic on view permit page

* adjust FE to better match anticipated BE. Get rid of key error on overview

* migration to store task id in a table. Stub in BE but I am getting NOT FOUND so namespace config must be wrong

* stub in BE functions

* MDS-6118 Added working permit condition flow

* MDS-6118 Fixed tasks + added tests

* MDS-6118 Fixed tests

* Mock celery task

* fix some front-end issues

* tidy up files

* update snaps

---------

Co-authored-by: Tara Epp <102187683+taraepp@users.noreply.github.com>
---
 Makefile                                      |   7 +
 ...9.58__add_permit_extraction_task_table.sql |  21 ++
 ...0.58__add_permit_condition_step_column.sql |   1 +
 ...d_permit_condition_step_column_version.sql |   1 +
 .../src/components/common/ActionMenu.tsx      |   1 +
 .../common/CoreTableCommonColumns.tsx         |   1 +
 services/common/src/constants/API.ts          |   4 +
 .../src/redux/reducers/rootReducerShared.ts   |   2 +
 .../src/redux/slices/permitServiceSlice.ts    | 203 ++++++++++++++++
 .../resources/download_token.py               |  18 +-
 services/core-api/app/api/mines/namespace.py  | 226 +++++++++++++-----
 .../models/permit_conditions.py               |  20 +-
 .../permits/permit_extraction/__init__.py     |   0
 .../create_permit_conditions.py               | 162 +++++++++++++
 .../models/permit_condition_result.py         |  39 +++
 .../models/permit_extraction_task.py          |  39 +++
 .../models/response_model.py                  |  20 ++
 .../permit_condition_extraction_resource.py   | 137 +++++++++++
 .../mines/permits/permit_extraction/tasks.py  |  23 ++
 .../search/search/permit_search_service.py    | 104 +++++++-
 .../api/services/document_manager_service.py  |  60 ++++-
 .../generate_history_table_migration.py       |  46 +++-
 services/core-api/app/commands.py             |  54 ++++-
 services/core-api/requirements.txt            |   3 +-
 .../test_mine_document_list_resource.py       |  29 ++-
 ...st_permit_condition_extraction_resource.py | 209 ++++++++++++++++
 ...test_create_permit_conditions_from_task.py | 162 +++++++++++++
 .../permits/permit_extraction/test_tasks.py   |  56 +++++
 .../mine/Permit/PermitConditionExtraction.tsx |  56 +++++
 .../mine/Permit/PermitConditions.tsx          |  26 ++
 .../src/components/mine/Permit/ViewPermit.tsx | 143 +++++++++--
 .../mine/Permit/ViewPermitOverview.tsx        |   1 +
 .../__snapshots__/ViewPermit.spec.tsx.snap    |  35 +--
 .../ViewPermitOverview.spec.tsx.snap          |   1 +
 services/document-manager/backend/celery.sh   |   4 +-
 services/permits/tests/test_tasks.py          |  18 --
 36 files changed, 1758 insertions(+), 174 deletions(-)
 create mode 100644 migrations/sql/V2024.09.03.19.58__add_permit_extraction_task_table.sql
 create mode 100644 migrations/sql/V2024.09.03.20.58__add_permit_condition_step_column.sql
 create mode 100644 migrations/sql/V2024.09.03.20.59__add_permit_condition_step_column_version.sql
 create mode 100644 services/common/src/redux/slices/permitServiceSlice.ts
 create mode 100644 services/core-api/app/api/mines/permits/permit_extraction/__init__.py
 create mode 100644 services/core-api/app/api/mines/permits/permit_extraction/create_permit_conditions.py
 create mode 100644 services/core-api/app/api/mines/permits/permit_extraction/models/permit_condition_result.py
 create mode 100644 services/core-api/app/api/mines/permits/permit_extraction/models/permit_extraction_task.py
 create mode 100644 services/core-api/app/api/mines/permits/permit_extraction/models/response_model.py
 create mode 100644 services/core-api/app/api/mines/permits/permit_extraction/resources/permit_condition_extraction_resource.py
 create mode 100644 services/core-api/app/api/mines/permits/permit_extraction/tasks.py
 create mode 100644 services/core-api/tests/permits/permit_extraction/resources/test_permit_condition_extraction_resource.py
 create mode 100644 services/core-api/tests/permits/permit_extraction/test_create_permit_conditions_from_task.py
 create mode 100644 services/core-api/tests/permits/permit_extraction/test_tasks.py
 create mode 100644 services/core-web/src/components/mine/Permit/PermitConditionExtraction.tsx
 delete mode 100644 services/permits/tests/test_tasks.py

diff --git a/Makefile b/Makefile
index 851c1978f5..7e959dcac0 100644
--- a/Makefile
+++ b/Makefile
@@ -147,6 +147,13 @@ generate_history_table_migration:
 	@echo "+\n++ Generating history table migration ...\n+"
 	@docker compose $(DC_FILE) exec backend bash -c "flask generate_history_table_migration $(TABLE)"
 
+
+# Generates a migration file for the specified table
+# Usage: make generate_migration TABLE=<table_name>
+generate_table_migration:
+	@echo "+\n++ Generating history table migration ...\n+"
+	@docker compose $(DC_FILE) exec backend bash -c "flask generate_table_migration $(TABLE)"
+
 # initial project setup for local/codespaces development
 init:
 	@./bin/setup_codespaces.sh
diff --git a/migrations/sql/V2024.09.03.19.58__add_permit_extraction_task_table.sql b/migrations/sql/V2024.09.03.19.58__add_permit_extraction_task_table.sql
new file mode 100644
index 0000000000..90605edabb
--- /dev/null
+++ b/migrations/sql/V2024.09.03.19.58__add_permit_extraction_task_table.sql
@@ -0,0 +1,21 @@
+-- This file was generated by the generate_table_ddl command
+-- The file contains the corresponding history table definition for the permit_extraction_task table
+CREATE TABLE permit_extraction_task (
+	create_user VARCHAR(60) NOT NULL, 
+	create_timestamp TIMESTAMP WITHOUT TIME ZONE NOT NULL, 
+	update_user VARCHAR(60) NOT NULL, 
+	update_timestamp TIMESTAMP WITHOUT TIME ZONE NOT NULL, 
+	permit_extraction_task_id UUID NOT NULL, 
+	task_id VARCHAR(255) NOT NULL, 
+	task_status VARCHAR(255) NOT NULL, 
+	task_meta JSON, 
+	task_result JSON, 
+	core_status_task_id VARCHAR(255), 
+	permit_amendment_guid UUID NOT NULL, 
+	permit_amendment_document_guid UUID NOT NULL, 
+	PRIMARY KEY (permit_extraction_task_id), 
+	FOREIGN KEY(permit_amendment_guid) REFERENCES permit_amendment (permit_amendment_guid), 
+	FOREIGN KEY(permit_amendment_document_guid) REFERENCES permit_amendment_document (permit_amendment_document_guid)
+);
+CREATE INDEX IF NOT EXISTS permit_extraction_task_id_idx ON permit_extraction_task (task_id);
+CREATE INDEX IF NOT EXISTS permit_extraction_amend_guid_idx ON permit_extraction_task (permit_amendment_guid);
\ No newline at end of file
diff --git a/migrations/sql/V2024.09.03.20.58__add_permit_condition_step_column.sql b/migrations/sql/V2024.09.03.20.58__add_permit_condition_step_column.sql
new file mode 100644
index 0000000000..b7127d9fa9
--- /dev/null
+++ b/migrations/sql/V2024.09.03.20.58__add_permit_condition_step_column.sql
@@ -0,0 +1 @@
+ALTER TABLE permit_conditions ADD COLUMN step VARCHAR(50);
\ No newline at end of file
diff --git a/migrations/sql/V2024.09.03.20.59__add_permit_condition_step_column_version.sql b/migrations/sql/V2024.09.03.20.59__add_permit_condition_step_column_version.sql
new file mode 100644
index 0000000000..9fb7df4eb4
--- /dev/null
+++ b/migrations/sql/V2024.09.03.20.59__add_permit_condition_step_column_version.sql
@@ -0,0 +1 @@
+ALTER TABLE permit_conditions_version ADD COLUMN step VARCHAR(50);
\ No newline at end of file
diff --git a/services/common/src/components/common/ActionMenu.tsx b/services/common/src/components/common/ActionMenu.tsx
index 9112214a61..d0eff8ceae 100644
--- a/services/common/src/components/common/ActionMenu.tsx
+++ b/services/common/src/components/common/ActionMenu.tsx
@@ -24,6 +24,7 @@ export const generateActionMenuItems = (actionItems: ITableAction[], record) =>
       label: (
         <button
           type="button"
+          disabled={action.disabled}
           className={`full actions-dropdown-button`}
           data-testid={`action-button-${action.key}`}
           onClick={(event) => action.clickFunction(event, record)}
diff --git a/services/common/src/components/common/CoreTableCommonColumns.tsx b/services/common/src/components/common/CoreTableCommonColumns.tsx
index c647d07cdd..f5c975e0a9 100644
--- a/services/common/src/components/common/CoreTableCommonColumns.tsx
+++ b/services/common/src/components/common/CoreTableCommonColumns.tsx
@@ -88,6 +88,7 @@ export interface ITableAction {
   label: string;
   clickFunction: (event, record) => any;
   icon?: ReactNode;
+  disabled?: boolean;
 }
 
 export const renderActionsColumn = ({
diff --git a/services/common/src/constants/API.ts b/services/common/src/constants/API.ts
index 1ad44682a9..7687e80b0d 100644
--- a/services/common/src/constants/API.ts
+++ b/services/common/src/constants/API.ts
@@ -91,6 +91,10 @@ export const STANDARD_PERMIT_CONDITIONS = (noticeOfWorkType) =>
 export const STANDARD_PERMIT_CONDITION = (permitConditionGuid) =>
   `/mines/permits/standard-conditions/${permitConditionGuid}`;
 
+export const PERMIT_SERVICE_EXTRACTION = `/mines/permits/condition-extraction`;
+export const POLL_PERMIT_SERVICE_EXTRACTION = (taskId: string) =>
+  `/mines/permits/condition-extraction/${taskId}`;
+
 // Permits - Notices of Departure
 export const NOTICES_OF_DEPARTURE = () => `/notices-of-departure`;
 export const NOTICE_OF_DEPARTURE = (noticeOfDepartureGuid) =>
diff --git a/services/common/src/redux/reducers/rootReducerShared.ts b/services/common/src/redux/reducers/rootReducerShared.ts
index a83d4a35f3..95386606f1 100644
--- a/services/common/src/redux/reducers/rootReducerShared.ts
+++ b/services/common/src/redux/reducers/rootReducerShared.ts
@@ -36,6 +36,7 @@ import verifiableCredentialsReducer from "@mds/common/redux/slices/verifiableCre
 import regionsReducer from "@mds/common/redux/slices/regionsSlice";
 import complianceCodeReducer, { complianceCodeReducerType } from "../slices/complianceCodesSlice";
 import spatialDataReducer, { spatialDataReducerType } from "../slices/spatialDataSlice";
+import permitServiceReducer, { permitServiceReducerType } from "../slices/permitServiceSlice";
 export const sharedReducer = {
   ...activityReducer,
   ...authenticationReducer,
@@ -82,4 +83,5 @@ export const sharedReducer = {
   regions: regionsReducer,
   [spatialDataReducerType]: spatialDataReducer,
   [complianceCodeReducerType]: complianceCodeReducer,
+  [permitServiceReducerType]: permitServiceReducer,
 };
diff --git a/services/common/src/redux/slices/permitServiceSlice.ts b/services/common/src/redux/slices/permitServiceSlice.ts
new file mode 100644
index 0000000000..4564c13ad1
--- /dev/null
+++ b/services/common/src/redux/slices/permitServiceSlice.ts
@@ -0,0 +1,203 @@
+import { createAppSlice, rejectHandler } from "@mds/common/redux/createAppSlice";
+import { hideLoading, showLoading } from "react-redux-loading-bar";
+import CustomAxios from "@mds/common/redux/customAxios";
+import { ItemMap } from "@mds/common/interfaces";
+import {
+  ENVIRONMENT,
+  PERMIT_SERVICE_EXTRACTION,
+  POLL_PERMIT_SERVICE_EXTRACTION,
+} from "@mds/common/constants";
+import { createSelector } from "@reduxjs/toolkit";
+
+const createRequestHeader = REQUEST_HEADER.createRequestHeader;
+
+export const permitServiceReducerType = "permitService";
+
+export enum PermitExtractionStatus {
+  not_started = "Not Started",
+  in_progress = "In Progress",
+  complete = "Extraction Complete",
+  error = "Error Extracting",
+}
+
+const permitExtractionStatusMap = {
+  PENDING: PermitExtractionStatus.in_progress,
+  RECEIVED: PermitExtractionStatus.in_progress,
+  PROGRESS: PermitExtractionStatus.in_progress,
+  RETRY: PermitExtractionStatus.in_progress,
+  STARTED: PermitExtractionStatus.in_progress,
+  REVOKED: PermitExtractionStatus.error,
+  FAILURE: PermitExtractionStatus.error,
+  SUCCESS: PermitExtractionStatus.complete,
+};
+
+interface PermitExtraction {
+  task_status: PermitExtractionStatus;
+  task_id: string;
+}
+
+interface PermitServiceState {
+  // object of: permit_amendment_id: {status: x, task_id: y}
+  extractions: ItemMap<PermitExtraction>;
+}
+
+const initialState: PermitServiceState = {
+  extractions: {},
+};
+
+const permitServiceSlice = createAppSlice({
+  name: permitServiceReducerType,
+  initialState,
+  reducers: (create) => ({
+    initiatePermitExtraction: create.asyncThunk(
+      async (
+        payload: { permit_amendment_id: number; permit_amendment_document_guid: string },
+        thunkAPI
+      ) => {
+        const headers = createRequestHeader();
+        thunkAPI.dispatch(showLoading());
+
+        const response = await CustomAxios({
+          errorToastMessage: "default",
+        }).post(`${ENVIRONMENT.apiUrl}${PERMIT_SERVICE_EXTRACTION}`, payload, headers);
+        thunkAPI.dispatch(hideLoading());
+
+        return response.data;
+      },
+      {
+        fulfilled: (state, action) => {
+          const { permit_amendment_id } = action.meta.arg;
+          const { task_id, task_status } = action.payload;
+          state.extractions[permit_amendment_id] = {
+            task_id,
+            task_status: permitExtractionStatusMap[task_status],
+          };
+        },
+        pending: (state, action) => {
+          const { permit_amendment_id } = action.meta.arg;
+          state.extractions[permit_amendment_id] = {
+            task_status: PermitExtractionStatus.in_progress,
+            task_id: null,
+          };
+        },
+        rejected: (state, action) => {
+          const { permit_amendment_id } = action.meta.arg;
+          state.extractions[permit_amendment_id] = {
+            task_status: PermitExtractionStatus.error,
+            task_id: null,
+          };
+          rejectHandler(action);
+        },
+      }
+    ),
+    fetchPermitExtractionTasks: create.asyncThunk(
+      async (payload: { permit_amendment_id: number }, thunkAPI) => {
+        const { permit_amendment_id } = payload;
+        const headers = createRequestHeader();
+        thunkAPI.dispatch(showLoading());
+
+        const response = await CustomAxios({
+          errorToastMessage: "default",
+        }).get(
+          `${ENVIRONMENT.apiUrl}${PERMIT_SERVICE_EXTRACTION}?permit_amendment_id=${permit_amendment_id}`,
+          headers
+        );
+
+        thunkAPI.dispatch(hideLoading());
+        return response.data.tasks[0];
+      },
+      {
+        fulfilled: (state, action) => {
+          if (!action.payload) return;
+          const { permit_amendment_id } = action.meta.arg;
+          const { task_id, task_status } = action.payload;
+          state.extractions[permit_amendment_id] = {
+            task_id: task_id,
+            task_status: permitExtractionStatusMap[task_status],
+          };
+        },
+        rejected: (state, action) => {
+          rejectHandler(action);
+        },
+      }
+    ),
+
+    fetchPermitExtractionStatus: create.asyncThunk(
+      async (payload: { permit_amendment_id: number; task_id: string }, thunkAPI) => {
+        const { task_id } = payload;
+
+        const headers = createRequestHeader();
+        thunkAPI.dispatch(showLoading());
+
+        const response = await CustomAxios({
+          errorToastMessage: "default",
+        }).get(`${ENVIRONMENT.apiUrl}${POLL_PERMIT_SERVICE_EXTRACTION(task_id)}`, headers);
+
+        thunkAPI.dispatch(hideLoading());
+        return response.data;
+      },
+      {
+        fulfilled: (state, action) => {
+          const { permit_amendment_id } = action.meta.arg;
+          const { task_id, task_status } = action.payload;
+          state.extractions[permit_amendment_id] = {
+            task_id: task_id,
+            task_status: permitExtractionStatusMap[task_status],
+          };
+        },
+        rejected: (state, action) => {
+          rejectHandler(action);
+        },
+      }
+    ),
+    deletePermitConditions: create.asyncThunk(
+      async (payload: { permit_amendment_id: number }, thunkAPI) => {
+        const headers = createRequestHeader();
+        thunkAPI.dispatch(showLoading());
+        const { permit_amendment_id } = payload;
+        const response = await CustomAxios({
+          errorToastMessage: "default",
+        }).delete(
+          `${ENVIRONMENT.apiUrl}${PERMIT_SERVICE_EXTRACTION}?permit_amendment_id=${permit_amendment_id}`,
+          headers
+        );
+
+        thunkAPI.dispatch(hideLoading());
+        return response.data;
+      },
+      {
+        fulfilled: (state, action) => {
+          const { permit_amendment_id } = action.meta.arg;
+          state.extractions[permit_amendment_id] = {
+            task_status: PermitExtractionStatus.not_started,
+            task_id: null,
+          };
+        },
+        rejected: (state, action) => {
+          rejectHandler(action);
+        },
+      }
+    ),
+  }),
+  selectors: {
+    getPermitExtractionState: (state: PermitServiceState) => {
+      return state.extractions;
+    },
+  },
+});
+
+export const { getPermitExtractionState } = permitServiceSlice.selectors;
+export const {
+  initiatePermitExtraction,
+  fetchPermitExtractionStatus,
+  fetchPermitExtractionTasks,
+  deletePermitConditions,
+} = permitServiceSlice.actions;
+
+export const getPermitExtractionByGuid = (permit_amendment_id: number) =>
+  createSelector([getPermitExtractionState], (extractions) => {
+    return extractions[permit_amendment_id];
+  });
+
+const permitServiceReducer = permitServiceSlice.reducer;
+export default permitServiceReducer;
diff --git a/services/core-api/app/api/download_token/resources/download_token.py b/services/core-api/app/api/download_token/resources/download_token.py
index 4a7f1eb68a..74a197d33a 100644
--- a/services/core-api/app/api/download_token/resources/download_token.py
+++ b/services/core-api/app/api/download_token/resources/download_token.py
@@ -1,9 +1,13 @@
-import uuid
-from flask_restx import Resource, fields
 
-from app.extensions import api, cache
-from app.api.utils.access_decorators import requires_any_of, VIEW_ALL, MINESPACE_PROPONENT, GIS
-from app.api.constants import DOWNLOAD_TOKEN, TIMEOUT_5_MINUTES
+from app.api.services.document_manager_service import DocumentManagerService
+from app.api.utils.access_decorators import (
+    GIS,
+    MINESPACE_PROPONENT,
+    VIEW_ALL,
+    requires_any_of,
+)
+from app.extensions import api
+from flask_restx import Resource, fields
 
 DOWNLOAD_TOKEN_MODEL = api.model('DownloadToken', {'token_guid': fields.String})
 
@@ -13,6 +17,4 @@ class DownloadTokenResource(Resource):
     @api.marshal_with(DOWNLOAD_TOKEN_MODEL, code=200)
     @requires_any_of([VIEW_ALL, MINESPACE_PROPONENT, GIS])
     def get(self, document_guid):
-        token_guid = uuid.uuid4()
-        cache.set(DOWNLOAD_TOKEN(token_guid), document_guid, TIMEOUT_5_MINUTES)
-        return {'token_guid': token_guid}
+        return {'token_guid': DocumentManagerService.create_download_token(document_guid)}
diff --git a/services/core-api/app/api/mines/namespace.py b/services/core-api/app/api/mines/namespace.py
index 89fc04a67f..576a648def 100644
--- a/services/core-api/app/api/mines/namespace.py
+++ b/services/core-api/app/api/mines/namespace.py
@@ -1,64 +1,180 @@
-from flask_restx import Namespace
-
-from app.api.mines.documents.resources.mine_document_bundle import MineDocumentBundleResource
-from app.api.mines.documents.resources.mine_document_version_resource import MineDocumentVersionListResource, MineDocumentVersionUploadResource
+from app.api.mines.alerts.resources.mine_alert import (
+    GlobalMineAlertListResource,
+    MineAlertListResource,
+    MineAlertResource,
+)
+from app.api.mines.comments.resources.mine_comment import (
+    MineCommentListResource,
+    MineCommentResource,
+)
 from app.api.mines.compliance.resources.compliance import MineComplianceSummaryResource
-from app.api.mines.documents.resources.mine_document_resource import MineDocumentListResource, MineDocumentArchiveResource, ZipResource, ZipProgressResource, DocumentUploadStatusResource
-from app.api.mines.explosives_permit_amendment.resources.explosives_permit_amendment import \
-    ExplosivesPermitAmendmentResource
-from app.api.mines.explosives_permit_amendment.resources.explosives_permit_amendment_list import \
-    ExplosivesPermitAmendmentListResource
-from app.api.mines.incidents.resources.mine_incidents import MineIncidentListResource, MineIncidentResource
-from app.api.mines.incidents.resources.mine_incident_document import MineIncidentDocumentListResource, MineIncidentDocumentResource
-from app.api.mines.mine.resources.mine_map import MineMapResource
-from app.api.mines.mine.resources.mine import MineResource, MineListSearch, MineListResource
-from app.api.mines.mine.resources.mine_type import MineTypeResource, MineTypeListResource
-from app.api.mines.mine.resources.mine_tenure_type_code import MineTenureTypeCodeResource
-from app.api.mines.mine.resources.mine_disturbance_code import MineDisturbanceCodeResource
-from app.api.mines.mine.resources.mine_commodity_code import MineCommodityCodeResource
-from app.api.mines.mine.resources.mine_verified_status import MineVerifiedStatusResource, MineVerifiedStatusListResource
+from app.api.mines.documents.resources.mine_document_bundle import (
+    MineDocumentBundleResource,
+)
+from app.api.mines.documents.resources.mine_document_resource import (
+    DocumentUploadStatusResource,
+    MineDocumentArchiveResource,
+    MineDocumentListResource,
+    ZipProgressResource,
+    ZipResource,
+)
+from app.api.mines.documents.resources.mine_document_version_resource import (
+    MineDocumentVersionListResource,
+    MineDocumentVersionUploadResource,
+)
+from app.api.mines.explosives_permit.resources.explosives_permit import (
+    ExplosivesPermitResource,
+)
+from app.api.mines.explosives_permit.resources.explosives_permit_document_type import (
+    ExplosivesPermitDocumentGenerateResource,
+    ExplosivesPermitDocumentTypeListResource,
+    ExplosivesPermitDocumentTypeResource,
+)
+from app.api.mines.explosives_permit.resources.explosives_permit_document_upload import (
+    ExplosivesPermitDocumentUploadResource,
+)
+from app.api.mines.explosives_permit.resources.explosives_permit_list import (
+    ExplosivesPermitListResource,
+)
+from app.api.mines.explosives_permit_amendment.resources.explosives_permit_amendment import (
+    ExplosivesPermitAmendmentResource,
+)
+from app.api.mines.explosives_permit_amendment.resources.explosives_permit_amendment_list import (
+    ExplosivesPermitAmendmentListResource,
+)
+from app.api.mines.external_authorizations.resources.epic_resource import EPICResource
+from app.api.mines.incidents.resources.mine_incident_document import (
+    MineIncidentDocumentListResource,
+    MineIncidentDocumentResource,
+)
+from app.api.mines.incidents.resources.mine_incidents import (
+    MineIncidentListResource,
+    MineIncidentResource,
+)
+from app.api.mines.mine.resources.mine import (
+    MineListResource,
+    MineListSearch,
+    MineResource,
+)
 from app.api.mines.mine.resources.mine_basicinfo import MineBasicInfoResource
-from app.api.mines.permits.permit.resources.permit import PermitResource, PermitListResource
-from app.api.mines.permits.permit.resources.permit_status_code import PermitStatusCodeResource
-from app.api.mines.permits.permit_amendment.resources.permit_amendment import PermitAmendmentResource, PermitAmendmentListResource
-from app.api.mines.permits.permit_amendment.resources.permit_amendment_document import PermitAmendmentDocumentListResource, PermitAmendmentDocumentResource
-from app.api.mines.permits.permit_amendment.resources.permit_amendment_vc import PermitAmendmentVCResource
-from app.api.mines.permits.permit.resources.permit_document_upload import PermitDocumentUploadInitializationResource
-from app.api.mines.explosives_permit.resources.explosives_permit import ExplosivesPermitResource
-from app.api.mines.explosives_permit.resources.explosives_permit_list import ExplosivesPermitListResource
-from app.api.mines.explosives_permit.resources.explosives_permit_document_upload import ExplosivesPermitDocumentUploadResource
-from app.api.mines.explosives_permit.resources.explosives_permit_document_type import ExplosivesPermitDocumentTypeResource, ExplosivesPermitDocumentTypeListResource, ExplosivesPermitDocumentGenerateResource
+from app.api.mines.mine.resources.mine_commodity_code import MineCommodityCodeResource
+from app.api.mines.mine.resources.mine_disturbance_code import (
+    MineDisturbanceCodeResource,
+)
+from app.api.mines.mine.resources.mine_map import MineMapResource
+from app.api.mines.mine.resources.mine_tenure_type_code import (
+    MineTenureTypeCodeResource,
+)
+from app.api.mines.mine.resources.mine_type import (
+    MineTypeListResource,
+    MineTypeResource,
+)
+from app.api.mines.mine.resources.mine_verified_status import (
+    MineVerifiedStatusListResource,
+    MineVerifiedStatusResource,
+)
+from app.api.mines.permits.permit.resources.permit import (
+    PermitListResource,
+    PermitResource,
+)
+from app.api.mines.permits.permit.resources.permit_document_upload import (
+    PermitDocumentUploadInitializationResource,
+)
+from app.api.mines.permits.permit.resources.permit_status_code import (
+    PermitStatusCodeResource,
+)
+from app.api.mines.permits.permit_amendment.resources.permit_amendment import (
+    PermitAmendmentListResource,
+    PermitAmendmentResource,
+)
+from app.api.mines.permits.permit_amendment.resources.permit_amendment_document import (
+    PermitAmendmentDocumentListResource,
+    PermitAmendmentDocumentResource,
+)
+from app.api.mines.permits.permit_amendment.resources.permit_amendment_vc import (
+    PermitAmendmentVCResource,
+)
+from app.api.mines.permits.permit_conditions.resources.permit_condition_category_resource import (
+    PermitConditionCategoryResource,
+)
+from app.api.mines.permits.permit_conditions.resources.permit_condition_type_resource import (
+    PermitConditionTypeResource,
+)
+from app.api.mines.permits.permit_conditions.resources.permit_conditions_resource import (
+    PermitConditionsListResource,
+    PermitConditionsResource,
+)
+from app.api.mines.permits.permit_conditions.resources.standard_permit_conditions_list_resource import (
+    StandardPermitConditionsListResource,
+)
+from app.api.mines.permits.permit_conditions.resources.standard_permit_conditions_resource import (
+    StandardPermitConditionsResource,
+)
+from app.api.mines.permits.permit_extraction.resources.permit_condition_extraction_resource import (
+    PermitConditionExtractionProgressResource,
+    PermitConditionExtractionResource,
+)
 from app.api.mines.region.resources.region import MineRegionResource
-from app.api.mines.reports.resources.mine_report_definition_compliance_article_xref_resource import \
-    MineReportDefinitionComplianceArticleCreateResource, MineReportDefinitionComplianceArticleUpdateResource
-from app.api.mines.reports.resources.mine_report_document import MineReportDocumentListResource
+from app.api.mines.reports.resources.mine_report_category import (
+    MineReportCategoryListResource,
+)
+from app.api.mines.reports.resources.mine_report_comment import (
+    MineReportCommentListResource,
+    MineReportCommentResource,
+)
+from app.api.mines.reports.resources.mine_report_definition import (
+    MineReportDefinitionListResource,
+)
+from app.api.mines.reports.resources.mine_report_definition_compliance_article_xref_resource import (
+    MineReportDefinitionComplianceArticleCreateResource,
+    MineReportDefinitionComplianceArticleUpdateResource,
+)
+from app.api.mines.reports.resources.mine_report_document import (
+    MineReportDocumentListResource,
+)
+from app.api.mines.reports.resources.mine_report_submission_resource import (
+    ReportSubmissionResource,
+)
+from app.api.mines.reports.resources.mine_report_submission_status import (
+    MineReportSubmissionStatusResource,
+)
+from app.api.mines.reports.resources.mine_reports import (
+    MineReportListResource,
+    MineReportResource,
+)
 from app.api.mines.reports.resources.reports_resource import ReportsResource
-from app.api.mines.reports.resources.mine_reports import MineReportListResource, MineReportResource
-from app.api.mines.reports.resources.mine_report_submission_resource import ReportSubmissionResource
-from app.api.mines.reports.resources.mine_report_definition import MineReportDefinitionListResource
-from app.api.mines.reports.resources.mine_report_submission_status import MineReportSubmissionStatusResource
-from app.api.mines.reports.resources.mine_report_category import MineReportCategoryListResource
-from app.api.mines.reports.resources.mine_report_comment import MineReportCommentResource, MineReportCommentListResource
 from app.api.mines.status.resources.status import MineStatusXrefListResource
-from app.api.mines.subscription.resources.subscription import MineSubscriptionResource, MineSubscriptionListResource
-from app.api.mines.tailings.resources.tailings import MineTailingsStorageFacilityResource
-from app.api.mines.tailings.resources.tailings_list import MineTailingsStorageFacilityListResource
+from app.api.mines.subscription.resources.subscription import (
+    MineSubscriptionListResource,
+    MineSubscriptionResource,
+)
+from app.api.mines.tailings.resources.tailings import (
+    MineTailingsStorageFacilityResource,
+)
+from app.api.mines.tailings.resources.tailings_list import (
+    MineTailingsStorageFacilityListResource,
+)
 from app.api.mines.variances.resources.variance import MineVarianceResource
+from app.api.mines.variances.resources.variance_document_upload import (
+    MineVarianceDocumentUploadResource,
+)
 from app.api.mines.variances.resources.variance_list import MineVarianceListResource
-from app.api.mines.variances.resources.variance_document_upload import MineVarianceDocumentUploadResource
-from app.api.mines.variances.resources.variance_uploaded_documents import MineVarianceUploadedDocumentsResource
-from app.api.parties.party_appt.resources.mine_party_appt_document_upload_resource import MinePartyApptDocumentUploadResource
-from app.api.mines.comments.resources.mine_comment import MineCommentListResource, MineCommentResource
-from app.api.mines.permits.permit_conditions.resources.permit_conditions_resource import PermitConditionsListResource, PermitConditionsResource
-from app.api.mines.permits.permit_conditions.resources.standard_permit_conditions_resource import StandardPermitConditionsResource
-from app.api.mines.permits.permit_conditions.resources.standard_permit_conditions_list_resource import StandardPermitConditionsListResource
-from app.api.mines.permits.permit_conditions.resources.permit_condition_category_resource import PermitConditionCategoryResource
-from app.api.mines.permits.permit_conditions.resources.permit_condition_type_resource import PermitConditionTypeResource
-from app.api.mines.work_information.resources.work_information_list import MineWorkInformationListResource
-from app.api.mines.work_information.resources.work_information import MineWorkInformationResource
-from app.api.mines.external_authorizations.resources.epic_resource import EPICResource
-from app.api.notice_of_departure.resources.notice_of_departure_document import MineNoticeOfDepartureNewDocumentUploadResource
-from app.api.mines.alerts.resources.mine_alert import MineAlertListResource, MineAlertResource, GlobalMineAlertListResource
+from app.api.mines.variances.resources.variance_uploaded_documents import (
+    MineVarianceUploadedDocumentsResource,
+)
+from app.api.mines.work_information.resources.work_information import (
+    MineWorkInformationResource,
+)
+from app.api.mines.work_information.resources.work_information_list import (
+    MineWorkInformationListResource,
+)
+from app.api.notice_of_departure.resources.notice_of_departure_document import (
+    MineNoticeOfDepartureNewDocumentUploadResource,
+)
+from app.api.parties.party_appt.resources.mine_party_appt_document_upload_resource import (
+    MinePartyApptDocumentUploadResource,
+)
+from flask_restx import Namespace
 
 api = Namespace('mines', description='Mine related operations')
 
@@ -154,6 +270,8 @@
     PermitAmendmentResource,
     '/<string:mine_guid>/permits/<string:permit_guid>/amendments/<string:permit_amendment_guid>')
 
+api.add_resource(PermitConditionExtractionResource, '/permits/condition-extraction')
+api.add_resource(PermitConditionExtractionProgressResource, '/permits/condition-extraction/<string:task_id>')
 api.add_resource(
     PermitAmendmentVCResource,
     '/<string:mine_guid>/permits/<string:permit_guid>/amendments/<string:permit_amendment_guid>/verifiable-credential'
diff --git a/services/core-api/app/api/mines/permits/permit_conditions/models/permit_conditions.py b/services/core-api/app/api/mines/permits/permit_conditions/models/permit_conditions.py
index 9de905bcee..7883ad239b 100644
--- a/services/core-api/app/api/mines/permits/permit_conditions/models/permit_conditions.py
+++ b/services/core-api/app/api/mines/permits/permit_conditions/models/permit_conditions.py
@@ -1,17 +1,15 @@
-from datetime import datetime
-
 import uuid
+from datetime import datetime
 
-from sqlalchemy.dialects.postgresql import UUID
-from sqlalchemy.orm import validates, backref
+from app.api.utils.field_template import FieldTemplate
+from app.api.utils.list_lettering_helpers import num_to_letter, num_to_roman
+from app.api.utils.models_mixins import AuditMixin, Base, SoftDeleteMixin
 from app.extensions import db
-from sqlalchemy.schema import FetchedValue
 from marshmallow import fields, validate
+from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy.ext.hybrid import hybrid_property
-
-from app.api.utils.field_template import FieldTemplate
-from app.api.utils.models_mixins import SoftDeleteMixin, AuditMixin, Base
-from app.api.utils.list_lettering_helpers import num_to_letter, num_to_roman
+from sqlalchemy.orm import backref, validates
+from sqlalchemy.schema import FetchedValue
 
 
 class PermitConditions(SoftDeleteMixin, AuditMixin, Base):
@@ -39,6 +37,7 @@ class _ModelSchema(Base._ModelSchema):
     parent_permit_condition_id = db.Column(db.Integer,
                                            db.ForeignKey('permit_conditions.permit_condition_id'))
     display_order = db.Column(db.Integer, nullable=False)
+    _step = db.Column('step', db.String, nullable=True)
 
     __versioned__ = {}
 
@@ -54,6 +53,9 @@ def sub_conditions(self):
 
     @hybrid_property
     def step(self):
+        if self._step:
+            return self._step
+
         depth = 0
         condition = self
         while condition.parent_permit_condition_id is not None:
diff --git a/services/core-api/app/api/mines/permits/permit_extraction/__init__.py b/services/core-api/app/api/mines/permits/permit_extraction/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/services/core-api/app/api/mines/permits/permit_extraction/create_permit_conditions.py b/services/core-api/app/api/mines/permits/permit_extraction/create_permit_conditions.py
new file mode 100644
index 0000000000..b8fd3015b3
--- /dev/null
+++ b/services/core-api/app/api/mines/permits/permit_extraction/create_permit_conditions.py
@@ -0,0 +1,162 @@
+import uuid
+from difflib import SequenceMatcher
+from typing import List, Optional
+
+from app.api.mines.permits.permit_conditions.models.permit_condition_category import (
+    PermitConditionCategory,
+)
+from app.api.mines.permits.permit_conditions.models.permit_conditions import (
+    PermitConditions,
+)
+from app.api.mines.permits.permit_extraction.models.permit_extraction_task import (
+    PermitExtractionTask,
+)
+from app.extensions import db
+
+from .models.permit_condition_result import (
+    CreatePermitConditionsResult,
+    PermitConditionResult,
+)
+
+indentation_type_code_mapping = {
+    0: None,
+    1: 'SEC',
+    2: 'CON',
+    3: 'LIS',
+    4: 'LIS',
+    5: 'LIS',
+}
+
+def create_permit_conditions_from_task(task: PermitExtractionTask):
+    """
+    Create permit conditions from the task result.
+    """
+    result = task.task_result
+    last_condition_id_by_hierarchy = {}
+    condition_categories = PermitConditionCategory.get_all()
+    current_category = None
+
+    result = CreatePermitConditionsResult.model_validate(result)
+
+    for idx, condition in enumerate(result.conditions):
+        
+        if condition.is_top_level_section:        
+            section_category = _map_condition_to_category(condition_categories, condition)
+
+            if section_category:
+                current_category = section_category
+        else:            
+            parent = _determine_parent(condition, last_condition_id_by_hierarchy)
+            type_code = _map_condition_to_type_code(condition)
+
+            title_cond = None
+            if condition.condition_title:
+                title_cond = _create_title_condition(task, current_category, condition, parent, idx, type_code)
+
+            parent_condition_id = _get_parent_condition_id(title_cond, parent)
+            cond = _create_permit_condition(task, current_category, condition, parent_condition_id, idx, type_code)
+
+            hierarchy_key = ".".join(condition.numbering_structure)
+            last_condition_id_by_hierarchy[hierarchy_key] = cond
+    db.session.commit()
+
+    
+
+def _map_condition_to_type_code(condition: PermitConditionResult):
+    """
+    The type code is based on the indentation level of the condition
+    Example: ['A', '1', 'a', 'i', ''] would have an indentation of 4 -> type code is 'LIS'
+    Example: ['A', '1', '', '', ''] would have an indentation of 2 -> type code is 'CON'
+    Example: ['A', '', '', '', ''] would have an indentation of 1 -> type code is 'SEC'
+    """
+    indentation = next((i-1 for i, x in enumerate(condition.numbering_structure) if x == ''), 0)
+    type_code = indentation_type_code_mapping[indentation]
+    return type_code
+
+def _create_title_condition(task, current_category, condition, parent, idx, type_code) -> PermitConditionResult:
+    condition = PermitConditions(
+        permit_amendment_id=task.permit_amendment.permit_amendment_id,
+        permit_condition_guid=uuid.uuid4(),
+        condition_category_code=current_category,
+        condition=condition.condition_title,
+        condition_type_code=type_code,
+        parent_permit_condition_id=parent.permit_condition_id if parent else None,
+        display_order=idx,
+        _step=condition.step,
+    )
+
+    db.session.add(condition)
+    db.session.flush()  # This assigns an ID to title_cond without committing the transaction
+    return condition
+
+def _get_parent_condition_id(title_cond: PermitConditionResult, parent: PermitConditionResult) -> Optional[str]:
+    if title_cond:
+        # If the condition has a title, the parent is the title condition
+        return title_cond.permit_condition_id
+    elif parent:
+        return parent.permit_condition_id
+    else:
+        return None
+
+def _create_permit_condition(task, current_category, condition, parent_condition_id, idx, type_code) -> PermitConditions:
+    condition = PermitConditions(
+        permit_amendment_id=task.permit_amendment.permit_amendment_id,
+        permit_condition_guid=uuid.uuid4(),
+        condition_category_code=current_category,
+        condition=condition.condition_text,
+        condition_type_code=type_code,
+        parent_permit_condition_id=parent_condition_id,
+        display_order=idx,
+        _step=condition.step if not condition.condition_title else '', # If the condition has a title, the parent is the title condition, which has the numbering associated with it already
+    )
+    db.session.add(condition)
+    db.session.flush()  # This assigns an ID to cond without committing the transaction
+
+    return condition
+
+
+def _determine_parent(condition: PermitConditionResult, last_condition_id_by_number_structure) -> Optional[PermitConditionResult]:
+    """
+    Determine the parent ID based on the hierarchy.
+
+    Example:
+    - If the hierarchy is ['A', '1', 'a', 'i', ''], the parent is the condition with the hierarchy ['A', '1', 'a', '', '']
+    """
+    number_structure = condition.numbering_structure
+    parent_number_structure = [item for item in number_structure if item][:-1]
+
+    if len(parent_number_structure) < len(number_structure):
+        parent_number_structure += [''] * (len(number_structure) - len(parent_number_structure))
+
+    parent_key = ".".join(parent_number_structure)
+
+    parent = last_condition_id_by_number_structure.get(parent_key)
+    return parent
+
+def _map_condition_to_category(condition_categories: List[PermitConditionCategory], condition: PermitConditionResult) -> Optional[str]:
+    """
+    Finds the matching PermitConditionCategory code for the given condition based on the title or text it contains.
+
+    If the condition title or text contains the category description (with a >0.6 ratio), it is considered a match
+
+    TODO:
+        - This is just in place to get something working that will map Major Mine categories to existing
+            regional mine permit categories. This will need to be updated to be more robust and flexible.
+        - The 0.6 ratio is just to cover cases where the condition text is not an exact match to the category description.
+            For example this will map the "Protection of Land and Watercourses" Major Mine category to the existing "Environmental Land and Watercourses" category.
+
+    Args:
+        condition_categories: List of PermitConditionCategory objects
+        condition: Condition object
+        
+    """
+    for cat in condition_categories:
+        desc = cat.description.lower().replace('conditions', '')
+        text = condition.condition_title if condition.condition_title else condition.condition_text
+        text = text.lower().replace('conditions', '')
+
+        if SequenceMatcher(None, desc, text).ratio() > 0.6:
+            return cat.condition_category_code
+    return None
+
+    
diff --git a/services/core-api/app/api/mines/permits/permit_extraction/models/permit_condition_result.py b/services/core-api/app/api/mines/permits/permit_extraction/models/permit_condition_result.py
new file mode 100644
index 0000000000..01a7febedd
--- /dev/null
+++ b/services/core-api/app/api/mines/permits/permit_extraction/models/permit_condition_result.py
@@ -0,0 +1,39 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, computed_field
+
+
+class PermitConditionResult(BaseModel):
+    section: Optional[str] = None
+    paragraph: Optional[str] = None
+    subparagraph: Optional[str] = None
+    clause: Optional[str] = None
+    subclause: Optional[str] = None
+    subsubclause: Optional[str] = None
+    condition_title: Optional[str] = None
+    condition_text: str
+
+    @computed_field
+    def numbering_structure(self) -> List[str]:
+        return [
+            self.section or '',
+            self.paragraph or '',
+            self.subparagraph or '',
+            self.clause or '',
+            self.subclause or '',
+            self.subsubclause or '',
+        ]
+
+    @computed_field
+    def is_top_level_section(self) -> bool:
+        # A condition is a top level section if it has a section but no other numbering
+        return self.section and not self.paragraph and not self.subparagraph and not self.clause and not self.subclause and not self.subsubclause
+    
+    @computed_field
+    def step(self) -> str:
+        # Numbering is the last non-empty value in the numbering structure.
+        # E.g. if the numbering structure is ['A', '1', 'a', 'i', ''], the numbering is 'i'
+        return next(cond for cond in reversed(self.numbering_structure) if cond and cond != '')
+
+class CreatePermitConditionsResult(BaseModel):
+    conditions: List[PermitConditionResult]
diff --git a/services/core-api/app/api/mines/permits/permit_extraction/models/permit_extraction_task.py b/services/core-api/app/api/mines/permits/permit_extraction/models/permit_extraction_task.py
new file mode 100644
index 0000000000..9eef6a0a2c
--- /dev/null
+++ b/services/core-api/app/api/mines/permits/permit_extraction/models/permit_extraction_task.py
@@ -0,0 +1,39 @@
+from app.api.utils.models_mixins import AuditMixin, Base
+from app.extensions import db
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.ext.associationproxy import association_proxy
+from sqlalchemy.schema import FetchedValue
+
+
+class PermitExtractionTask(AuditMixin, Base):
+    __tablename__ = 'permit_extraction_task'
+
+    permit_extraction_task_id = db.Column(
+        UUID(as_uuid=True), primary_key=True, server_default=db.FetchedValue())
+    task_id = db.Column(db.String(255), nullable=False)
+    task_status = db.Column(db.String(255), nullable=False)
+    task_meta = db.Column(db.JSON, nullable=True)
+    task_result = db.Column(db.JSON, nullable=True)
+
+    core_status_task_id = db.Column(db.String(255), nullable=True)
+    permit_amendment_guid = db.Column(
+        UUID(as_uuid=True), db.ForeignKey('permit_amendment.permit_amendment_guid'), nullable=False)
+    permit_amendment_document_guid = db.Column(
+        UUID(as_uuid=True), db.ForeignKey('permit_amendment_document.permit_amendment_document_guid'), nullable=False)
+
+    permit_amendment = db.relationship('PermitAmendment', lazy='select')
+
+    @staticmethod
+    def get_by_permit_extraction_task_id(permit_extraction_task_id):
+        return PermitExtractionTask.query.filter_by(permit_extraction_task_id=permit_extraction_task_id).order_by(PermitExtractionTask.create_timestamp.desc())
+    
+    @staticmethod
+    def get_by_permit_amendment_guid(permit_amendment_guid):
+        return PermitExtractionTask.query.filter_by(permit_amendment_guid=permit_amendment_guid).order_by(PermitExtractionTask.create_timestamp.desc()).all()
+
+    @classmethod
+    def create(cls, **kwargs):
+        obj = cls(**kwargs)
+        db.session.add(obj)
+        db.session.commit()
+        return obj
diff --git a/services/core-api/app/api/mines/permits/permit_extraction/models/response_model.py b/services/core-api/app/api/mines/permits/permit_extraction/models/response_model.py
new file mode 100644
index 0000000000..8ffa5de720
--- /dev/null
+++ b/services/core-api/app/api/mines/permits/permit_extraction/models/response_model.py
@@ -0,0 +1,20 @@
+from app.api.compliance.response_models import COMPLIANCE_ARTICLE_MODEL
+from app.api.dams.dto import DAM_MODEL
+from app.api.parties.party_appt.models.mine_party_appt import (
+    MinePartyAcknowledgedStatus,
+    MinePartyAppointmentStatus,
+)
+from app.api.parties.response_models import PARTY
+from app.api.utils.feature_flag import Feature, is_feature_enabled
+from app.extensions import api
+from flask_restx import fields, marshal
+
+PERMIT_CONDITION_EXTRACTION_TASK = api.model(
+    'PermitExtractionTask', {
+        'permit_extraction_task_id': fields.String,
+        'task_id': fields.String,
+        'task_status': fields.String,
+        'permit_amendment_guid': fields.String,
+        'permit_amendment_document_guid': fields.String,
+        'core_status_task_id': fields.String
+    })
diff --git a/services/core-api/app/api/mines/permits/permit_extraction/resources/permit_condition_extraction_resource.py b/services/core-api/app/api/mines/permits/permit_extraction/resources/permit_condition_extraction_resource.py
new file mode 100644
index 0000000000..d5e2fdabba
--- /dev/null
+++ b/services/core-api/app/api/mines/permits/permit_extraction/resources/permit_condition_extraction_resource.py
@@ -0,0 +1,137 @@
+from app.api.mines.permits.permit_amendment.models.permit_amendment import (
+    PermitAmendment,
+)
+from app.api.mines.permits.permit_amendment.models.permit_amendment_document import (
+    PermitAmendmentDocument,
+)
+from app.api.mines.permits.permit_conditions.models.permit_conditions import (
+    PermitConditions,
+)
+from app.api.mines.permits.permit_extraction.models.permit_extraction_task import (
+    PermitExtractionTask,
+)
+from app.api.mines.permits.permit_extraction.models.response_model import (
+    PERMIT_CONDITION_EXTRACTION_TASK,
+)
+from app.api.mines.permits.permit_extraction.tasks import (
+    poll_update_permit_extraction_status,
+)
+from app.api.search.search.permit_search_service import PermitSearchService
+from app.api.utils.access_decorators import (
+    VIEW_ALL,
+    requires_any_of,
+    requires_role_edit_standard_permit_conditions,
+)
+from app.api.utils.resources_mixins import UserMixin
+from app.extensions import api
+from flask_restx import Resource, reqparse
+from werkzeug.exceptions import BadRequest
+
+
+class PermitConditionExtractionResource(Resource, UserMixin):
+
+    @requires_role_edit_standard_permit_conditions
+    @api.doc(description='Trigger the extraction of conditions from a permit document')
+    @api.marshal_with(PERMIT_CONDITION_EXTRACTION_TASK, code=200)
+    def post(self):
+        parser = reqparse.RequestParser()
+        parser.add_argument(
+            'permit_amendment_id',
+            type=str,
+            location='json',
+            required=True,
+            help='Permit amendment id to perform condition extraction'
+        )
+        parser.add_argument(
+            'permit_amendment_document_guid',
+            type=str,
+            location='json',
+            required=True,
+            help='Reference to the PDF document to extract conditions from'
+        )
+
+        args = parser.parse_args()
+        permit_amendment_id = args.get('permit_amendment_id')
+        permit_amendment_document_guid = args.get('permit_amendment_document_guid')
+        
+        amendment_document = PermitAmendmentDocument.find_by_permit_amendment_document_guid(permit_amendment_document_guid)
+
+        if not amendment_document:
+            raise BadRequest('Permit document not found')
+        if str(amendment_document.permit_amendment_id) != str(permit_amendment_id):
+            raise BadRequest('Permit document must be associated with the permit amendment')
+        
+        permit_amendment = PermitAmendment.find_by_permit_amendment_id(permit_amendment_id)
+
+        if len(permit_amendment.conditions) > 0:
+            raise BadRequest('Permit conditions already exist for this permit amendment')
+
+        task = PermitSearchService().initialize_permit_extraction(amendment_document)
+
+        if task:
+            core_task = poll_update_permit_extraction_status.delay(task.permit_extraction_task_id)
+
+            task.core_status_task_id = core_task.id
+            task.save()
+        
+        return task
+
+    
+    @api.doc(description='Get all permit extraction tasks for a permit amendment')
+    @api.marshal_with(PERMIT_CONDITION_EXTRACTION_TASK, code=200, as_list=True, envelope='tasks')
+    @requires_any_of([VIEW_ALL])
+    def get(self):
+        parser = reqparse.RequestParser()
+
+        parser.add_argument(
+            'permit_amendment_id',
+            type=str,
+            location='args',
+            required=True,
+            help='Permit amendment id to perform condition extraction'
+        )
+        args = parser.parse_args()
+
+        amd = PermitAmendment.find_by_permit_amendment_id(args.get('permit_amendment_id'))
+
+        if not amd:
+            raise BadRequest('Permit amendment not found')
+
+        tasks = PermitExtractionTask.get_by_permit_amendment_guid(amd.permit_amendment_guid)
+
+        return tasks
+    
+
+    @api.doc(description='Delete all permit conditions associated with permit amendment')
+    @requires_role_edit_standard_permit_conditions
+    def delete(self):
+        parser = reqparse.RequestParser()
+
+        parser.add_argument(
+            'permit_amendment_id',
+            type=str,
+            location='args',
+            required=True,
+            help='Permit amendment id to perform condition extraction'
+        )
+        args = parser.parse_args()
+
+        PermitConditions.delete_all_by_permit_amendment_id(args['permit_amendment_id'], commit=True)
+
+
+class PermitConditionExtractionProgressResource(Resource, UserMixin):
+    api.doc('Returns the status of the permit extraction task')
+
+    @requires_any_of([VIEW_ALL])
+    @api.marshal_with(PERMIT_CONDITION_EXTRACTION_TASK, code=200)
+    @api.doc(description='Get the status of a permit extraction task')
+    def get(self, task_id):
+        if not task_id:
+            raise BadRequest('No task id provided')
+        
+        task = PermitExtractionTask.get_by_permit_extraction_task_id(task_id).first()
+
+        if not task:
+            raise BadRequest('Task not found')
+
+        return task
diff --git a/services/core-api/app/api/mines/permits/permit_extraction/tasks.py b/services/core-api/app/api/mines/permits/permit_extraction/tasks.py
new file mode 100644
index 0000000000..9eb52ae384
--- /dev/null
+++ b/services/core-api/app/api/mines/permits/permit_extraction/tasks.py
@@ -0,0 +1,23 @@
+
+from app.api.mines.permits.permit_extraction.create_permit_conditions import (
+    create_permit_conditions_from_task,
+)
+from app.api.search.search.permit_search_service import PermitSearchService
+from app.tasks.celery import celery
+
+
+@celery.task(max_retries=360)
+def poll_update_permit_extraction_status(permit_extraction_task_id):
+    """
+    Poll the permit conditions service for the status of the extraction task every 10s
+    until the task is complete (SUCCESS or FAILURE).
+    """
+    task = PermitSearchService().update_task_status(permit_extraction_task_id)
+
+    if task.task_status == 'SUCCESS' or task.task_status == 'FAILURE':
+        if task.task_status == 'SUCCESS':
+            create_permit_conditions_from_task(task)
+
+        return task
+    else:
+        poll_update_permit_extraction_status.retry(countdown=10)
diff --git a/services/core-api/app/api/search/search/permit_search_service.py b/services/core-api/app/api/search/search/permit_search_service.py
index 597a55af34..c521578a45 100644
--- a/services/core-api/app/api/search/search/permit_search_service.py
+++ b/services/core-api/app/api/search/search/permit_search_service.py
@@ -1,12 +1,35 @@
-import requests
-from authlib.integrations.requests_client import OAuth2Session
+import logging
 import os
+import tempfile
+import uuid
+from io import BytesIO
+
+import requests
+from app.api.mines.permits.permit.models.mine_permit_xref import MinePermitXref
+from app.api.mines.permits.permit.models.permit import Permit
+from app.api.mines.permits.permit_amendment.models.permit_amendment import (
+    PermitAmendment,
+)
+from app.api.mines.permits.permit_amendment.models.permit_amendment_document import (
+    PermitAmendmentDocument,
+)
+from app.api.mines.permits.permit_extraction.models.permit_extraction_task import (
+    PermitExtractionTask,
+)
+from app.api.services.document_manager_service import DocumentManagerService
 from app.config import Config
+from authlib.integrations.requests_client import OAuth2Session
+from flask import current_app
+from werkzeug.exceptions import InternalServerError
 
 JWT_OIDC_WELL_KNOWN_CONFIG = os.getenv('JWT_OIDC_WELL_KNOWN_CONFIG')
 
 oidc_configuration = requests.get(JWT_OIDC_WELL_KNOWN_CONFIG).json()
 SEARCH_ENDPOINT = f'{Config.PERMITS_ENDPOINT}/permit/query'
+EXTRACTION_ENDPOINT = f'{Config.PERMITS_ENDPOINT}/permit_conditions'
+EXTRACTION_STATUS_ENDPOINT = f'{Config.PERMITS_ENDPOINT}/permit_conditions/status'
+EXTRACTION_RESULTS_ENDPOINT = f'{Config.PERMITS_ENDPOINT}/permit_conditions/results'
+
 
 class PermitSearchService:
 
@@ -20,5 +43,80 @@ def search(self, search_term):
         Performs a search against the permit service by the `search_term`.
         """
         results = self.session.post(SEARCH_ENDPOINT, json={'query': search_term,'debug': False, 'params': {}}).json()
-
         return results['documents']
+
+    def initialize_permit_extraction(self, permit_amendment_document):
+        """
+        Begins the process of extracting permit conditions from a the PDF document.
+
+        1. Download the given document from Docman into a temporary file.
+        2. Trigger the extraction process by sending the file to the permit conditions service.
+        3. Create a new task to track the status of the extraction process.
+        """
+        document_manager_guid = permit_amendment_document.document_manager_guid
+
+        current_app.logger.info(f'Initiating permit extraction for document {document_manager_guid}')
+
+        with tempfile.NamedTemporaryFile() as file:
+            file_name, fle = DocumentManagerService().download_document_to_file(document_manager_guid, file)
+            fle.seek(0)
+
+            try:
+                files = {'file': (file_name or 'permit.pdf', fle, 'application/pdf')}
+                result = self.session.post(EXTRACTION_ENDPOINT, files=files)
+                
+                if result.status_code != 200:
+                    current_app.logger.error(f'Failed to extract permit conditions for document {document_manager_guid}. Status code: {result.status_code}. Response: {result.text}')
+                    raise InternalServerError('Failed to extract permit conditions. Could not download document')
+                data = result.json()
+                task = PermitExtractionTask.create(
+                    permit_extraction_task_id=uuid.uuid4(),
+                    task_id=data['id'],
+                    task_status=data['status'],
+                    permit_amendment_guid=permit_amendment_document.permit_amendment.permit_amendment_guid,
+                    permit_amendment_document_guid=permit_amendment_document.permit_amendment_document_guid,
+                    task_meta=data['meta']
+                )
+                return task                
+            except Exception as e:
+                current_app.logger.error(f'Failed to extract permit conditions for document {document_manager_guid}. Error: {str(e)}')
+                raise e
+
+    def update_task_status(self, permit_extraction_task_id):
+        """
+        Updates the status of the given permit extraction task, with the latest information from the permit conditions service.
+        
+        If the task is successful, retrieves the results of the extraction process and saves them to the task.
+        """
+        task = PermitExtractionTask.query.filter_by(permit_extraction_task_id=permit_extraction_task_id).first()
+
+        if not task:
+            raise InternalServerError('Task not found')
+        
+        result = self.session.get(f'{EXTRACTION_STATUS_ENDPOINT}?task_id={task.task_id}')
+
+        if result.status_code != 200:
+            current_app.logger.error(f'Failed to retrieve status of task from PermitService: {task.task_id}, status code: {result.status_code}. Response: {result.text}')
+            raise InternalServerError('Could not retrieve status of task')
+
+        data = result.json()
+
+        if task.task_status != data['status']:
+            current_app.logger.info(f'Updating permit condition extract task status for task {task.task_id} from {task.task_status} to {data["status"]}')
+
+        task.task_status = data['status']
+        task.meta = data['meta']
+
+        if data['status'] == 'SUCCESS':
+            results_response = self.session.get(f'{EXTRACTION_RESULTS_ENDPOINT}?task_id={task.task_id}')
+
+            if results_response.status_code != 200:
+                current_app.logger.error(f'Failed to retrieve the result of task from PermitService: {task.task_id}, status code: {result.status_code}. Response: {result.text}')
+                raise InternalServerError('Something went wrong')
+            
+            data = results_response.json()
+
+            task.task_result = data
+
+        task.save()
+        return task
diff --git a/services/core-api/app/api/services/document_manager_service.py b/services/core-api/app/api/services/document_manager_service.py
index 9e4c0750f7..683ad4153b 100644
--- a/services/core-api/app/api/services/document_manager_service.py
+++ b/services/core-api/app/api/services/document_manager_service.py
@@ -1,17 +1,27 @@
-import time
-import requests
 import base64
 import io
 import json
-from tusclient import client
+import logging
+import re
+import time
+import uuid
 
-from flask import Response, current_app, request as flask_request
-from flask_restx import marshal, fields
-from app.config import Config
-from app.api.now_applications.response_models import NOW_SUBMISSION_DOCUMENT
-from app.api.now_applications.models.now_application_document_identity_xref import NOWApplicationDocumentIdentityXref
+import requests
+from app.api.constants import DOWNLOAD_TOKEN, TIMEOUT_5_MINUTES
 from app.api.mines.documents.mine_document_search_util import MineDocumentSearchUtil
 from app.api.mines.documents.models.mine_document import MineDocument
+from app.api.now_applications.models.now_application_document_identity_xref import (
+    NOWApplicationDocumentIdentityXref,
+)
+from app.api.now_applications.response_models import NOW_SUBMISSION_DOCUMENT
+from app.config import Config
+from app.extensions import cache
+from flask import Response, current_app
+from flask import request as flask_request
+from flask_restx import fields, marshal
+from tusclient import client
+
+logger = logging.getLogger(__name__)
 
 ALLOWED_DOCUMENT_CATEGORIES = [
     'tailings', 'permits', 'variances', 'incidents', 'reports', 'mine_party_appts', 'noticeofwork',
@@ -270,3 +280,37 @@ def wait_for_document_upload(cls, document_manager_guid, timeout=60):
                 raise Exception('Timed out while waiting for file upload to finish')
 
             time.sleep(1)
+
+    @classmethod
+    def create_download_token(cls, document_guid):
+        token_guid = uuid.uuid4()
+        cache.set(DOWNLOAD_TOKEN(token_guid), document_guid, TIMEOUT_5_MINUTES)
+        return token_guid
+
+    @classmethod
+    def download_document_to_file(cls, document_guid, file_obj):
+        token = cls.create_download_token(document_guid)
+
+        resp = requests.get(
+            url=f'{Config.DOCUMENT_MANAGER_URL}/documents?token={token}',
+            headers=flask_request.headers,
+            stream=True
+        )
+        
+        if resp.status_code != 200:
+            raise Exception(f'Failed to download document. {resp.status_code}: {resp.text}')
+
+        file_name = None
+
+        content_disposition = resp.headers['content-disposition']
+
+        if content_disposition:
+            fname = re.findall("filename=(.+)", content_disposition)
+
+            if len(fname) > 0:
+                file_name = fname[0]
+
+        for chunk in resp.iter_content(chunk_size=1024):
+            if chunk:
+                file_obj.write(chunk)
+        return file_name, file_obj
\ No newline at end of file
diff --git a/services/core-api/app/cli_commands/generate_history_table_migration.py b/services/core-api/app/cli_commands/generate_history_table_migration.py
index b9d4a32601..f169ba5823 100644
--- a/services/core-api/app/cli_commands/generate_history_table_migration.py
+++ b/services/core-api/app/cli_commands/generate_history_table_migration.py
@@ -1,11 +1,10 @@
 
 import datetime
 
-from sqlalchemy.schema import CreateTable, CreateIndex
+from app.extensions import db
 from sqlalchemy.dialects import postgresql
+from sqlalchemy.schema import CreateIndex, CreateTable
 
-from app.extensions import db
-    
 
 def generate_history_table_migration(table):
     """
@@ -83,3 +82,44 @@ def generate_version_table_migration(version_table_name, version_table_definitio
             index_statement = str(CreateIndex(index).compile(dialect=postgresql.dialect())).strip()
             f.write(index_statement)
             f.write(';\n')
+
+
+
+def generate_table_migration(table):
+    """
+    Generates a flyway migration file that creates a table for the specified SQLAlchemy model.
+    
+    Make sure to review the output and adjust as necessary before running the migration.
+    
+    The command uses SQLAlchemy-continuum and built in SQLAlchemy model reflection to generate the history table definition.    
+    """
+
+    print(f'Generating history table definition for table: {table}')
+
+    # Find the SQLAlchemy model for the table
+    table_class = next((c for c in db.Model.registry.mappers if c.class_.__tablename__ == table), None)
+
+    if table_class is None:
+        print(f'Could not find SQLAlchemy model for table {table}')
+        return
+
+    do_generate_table_migration(table, table_class.class_.__table__)
+
+
+def do_generate_table_migration(table_name, table_definition):
+    dt = datetime.datetime.today().strftime('%Y.%m.%d.%H.%M')
+
+    migration_name = f'/migrations/sql/V{dt}__add_{table_name}_table.sql'
+
+    create_table_statement = str(CreateTable(table_definition).compile(dialect=postgresql.dialect())).strip()
+
+    with open(migration_name, 'w') as f:
+        f.write("-- This file was generated by the generate_table_ddl command\n")
+        f.write(f"-- The file contains the corresponding history table definition for the {table_name} table\n")
+        f.write(create_table_statement)
+        f.write(';\n')
+
+        for index in table_definition.indexes:
+            index_statement = str(CreateIndex(index).compile(dialect=postgresql.dialect())).strip()
+            f.write(index_statement)
+            f.write(';\n')
diff --git a/services/core-api/app/commands.py b/services/core-api/app/commands.py
index a77e8399ae..797a4fcbf9 100644
--- a/services/core-api/app/commands.py
+++ b/services/core-api/app/commands.py
@@ -1,16 +1,24 @@
-import click
-
-from sqlalchemy.exc import DBAPIError
 from multiprocessing.dummy import Pool as ThreadPool
-from flask import current_app
 
+import click
+from app.api.mines.permits.permit.models.permit import Permit
 from app.api.utils.include.user_info import User
 from app.extensions import db
+from flask import current_app
+from sqlalchemy.exc import DBAPIError
+from tests.factories import (
+    MineFactory,
+    MinePartyAppointmentFactory,
+    MinespaceSubscriptionFactory,
+    MinespaceUserFactory,
+    NOWApplicationIdentityFactory,
+    NOWSubmissionFactory,
+)
 
-from app.api.mines.permits.permit.models.permit import Permit
-
-from tests.factories import MineFactory, MinePartyAppointmentFactory, MinespaceSubscriptionFactory, MinespaceUserFactory, NOWSubmissionFactory, NOWApplicationIdentityFactory
-from .cli_commands.generate_history_table_migration import generate_history_table_migration
+from .cli_commands.generate_history_table_migration import (
+    generate_history_table_migration,
+    generate_table_migration,
+)
 
 
 def register_commands(app):
@@ -115,8 +123,8 @@ def run_address_etl():
 
     @app.cli.command('notify_expiring_party_appointments')
     def notify_expiring_party_appointments():
-        from app.api.parties.party_appt import notify_expiring_party_appointments
         from app import auth
+        from app.api.parties.party_appt import notify_expiring_party_appointments
         auth.apply_security = False
 
         with current_app.app_context():
@@ -124,8 +132,10 @@ def notify_expiring_party_appointments():
 
     @app.cli.command('notify_and_update_expired_party_appointments')
     def notify_and_update_expired_party_appointments():
-        from app.api.parties.party_appt import notify_and_update_expired_party_appointments
         from app import auth
+        from app.api.parties.party_appt import (
+            notify_and_update_expired_party_appointments,
+        )
         auth.apply_security = False
 
         with current_app.app_context():
@@ -135,8 +145,10 @@ def notify_and_update_expired_party_appointments():
     @click.argument('credential_exchange_id')
     @click.argument('permit_guid')
     def revoke_mines_act_permits_for_permit(credential_exchange_id, permit_guid):
-        from app.api.verifiable_credentials.manager import revoke_all_credentials_for_permit
         from app import auth
+        from app.api.verifiable_credentials.manager import (
+            revoke_all_credentials_for_permit,
+        )
         auth.apply_security = False
         with current_app.app_context():
             permit = Permit.query.unbound_unsafe().filter_by(permit_guid=permit_guid).first()
@@ -146,16 +158,20 @@ def revoke_mines_act_permits_for_permit(credential_exchange_id, permit_guid):
 
     @app.cli.command('process_all_untp_map_for_orgbook')
     def process_all_untp_map_for_orgbook():
-        from app.api.verifiable_credentials.manager import process_all_untp_map_for_orgbook
         from app import auth
+        from app.api.verifiable_credentials.manager import (
+            process_all_untp_map_for_orgbook,
+        )
         auth.apply_security = False
         with current_app.app_context() as app:
             result = process_all_untp_map_for_orgbook.apply_async()
 
     @app.cli.command('publish_all_pending_vc_to_orgbook')
     def publish_all_pending_vc_to_orgbook():
-        from app.api.verifiable_credentials.manager import publish_all_pending_vc_to_orgbook
         from app import auth
+        from app.api.verifiable_credentials.manager import (
+            publish_all_pending_vc_to_orgbook,
+        )
         auth.apply_security = False
         with current_app.app_context():
             result = publish_all_pending_vc_to_orgbook()
@@ -171,3 +187,15 @@ def do_generate_history_table_command(table):
             flask generate_history_table_migration mine_tailings_storage_facility
         """
         generate_history_table_migration(table)
+
+    @app.cli.command('generate_table_migration')
+    @click.argument('table')
+    def do_generate_table_command(table):
+        """
+        Generate a migration file that contains the table definition for the specified table.
+        Uses SQLAlchemy-continuum to generate the table definition.
+
+        Example usage:
+            flask generate_table_migration mine_tailings_storage_facility
+        """
+        generate_table_migration(table)
\ No newline at end of file
diff --git a/services/core-api/requirements.txt b/services/core-api/requirements.txt
index 347f2f1c90..28a9135bc1 100644
--- a/services/core-api/requirements.txt
+++ b/services/core-api/requirements.txt
@@ -55,5 +55,6 @@ opentelemetry-instrumentation-sqlalchemy==0.43b0
 opentelemetry-instrumentation-urllib3==0.43b0
 Pillow==10.3.0
 setuptools==65.5.1
+requests_toolbelt==1.0.0
 untp_models==0.0.2
-urllib3==2.2.2
\ No newline at end of file
+urllib3==2.2.2
diff --git a/services/core-api/tests/mines/documents/test_mine_document_list_resource.py b/services/core-api/tests/mines/documents/test_mine_document_list_resource.py
index ea17c53284..6b375a45d7 100644
--- a/services/core-api/tests/mines/documents/test_mine_document_list_resource.py
+++ b/services/core-api/tests/mines/documents/test_mine_document_list_resource.py
@@ -1,12 +1,23 @@
-import pytest
 import json
 import uuid
 
-from tests.status_code_gen import RandomIncidentDocumentType
-from tests.factories import (InformationRequirementsTableFactory, MajorMineApplicationFactory, MineIncidentFactory, MineFactory, MineDocumentFactory, ProjectDecisionPackageFactory, ProjectFactory, ProjectSummaryDocumentFactory, ProjectSummaryFactory,
-                             VarianceDocumentFactory, VarianceFactory)
-from app.api.projects.project_summary.models.project_summary import ProjectSummary
+import pytest
 from app.api.mines.documents.models.mine_document import MineDocument
+from app.api.projects.project_summary.models.project_summary import ProjectSummary
+from tests.factories import (
+    InformationRequirementsTableFactory,
+    MajorMineApplicationFactory,
+    MineDocumentFactory,
+    MineFactory,
+    MineIncidentFactory,
+    ProjectDecisionPackageFactory,
+    ProjectFactory,
+    ProjectSummaryDocumentFactory,
+    ProjectSummaryFactory,
+    VarianceDocumentFactory,
+    VarianceFactory,
+)
+from tests.status_code_gen import RandomIncidentDocumentType
 
 
 @pytest.fixture(scope="function")
@@ -95,7 +106,13 @@ def test_list_resource_filter_by_project_summary_guid(self, test_client, db_sess
         get_data = json.loads(get_resp.data.decode())
 
         assert len(get_data['records']) == 2
-        assert str(ps.documents[0].mine_document_guid) == get_data['records'][0]['mine_document_guid']
+
+        guids = (str(ps.documents[0].mine_document_guid), str(ps.documents[1].mine_document_guid))
+
+
+        assert get_data['records'][0]['mine_document_guid'] in guids
+        assert get_data['records'][1]['mine_document_guid'] in guids
+        
 
     def test_list_resource_filter_by_project_decision_package_guid(self, test_client, db_session, auth_headers, setup_info):
         """Should only return documents related to the project decision package"""
diff --git a/services/core-api/tests/permits/permit_extraction/resources/test_permit_condition_extraction_resource.py b/services/core-api/tests/permits/permit_extraction/resources/test_permit_condition_extraction_resource.py
new file mode 100644
index 0000000000..d8b0a490bd
--- /dev/null
+++ b/services/core-api/tests/permits/permit_extraction/resources/test_permit_condition_extraction_resource.py
@@ -0,0 +1,209 @@
+import json
+import uuid
+from unittest import mock
+
+import pytest
+import responses
+from app.api.mines.permits.permit_conditions.models.permit_conditions import (
+    PermitConditions,
+)
+from app.api.mines.permits.permit_extraction.models.permit_extraction_task import (
+    PermitExtractionTask,
+)
+from app.config import Config
+from app.extensions import db
+from app.tasks.celery import celery
+from tests.factories import PermitAmendmentDocumentFactory, create_mine_and_permit
+
+
+@pytest.fixture(scope='function')
+def pc_test_data(test_client, db_session):
+    mine, permit = create_mine_and_permit()
+
+    amendment = permit.permit_amendments[0]
+    amendment_document = PermitAmendmentDocumentFactory(permit_amendment=amendment)
+
+    yield (amendment, amendment_document)
+
+
+def test_post_permit_condition_fails_with_existing_conditions(pc_test_data, auth_headers, test_client, db_session):
+    amendment, amendment_document = pc_test_data
+
+    data = {
+        'permit_amendment_id': str(amendment.permit_amendment_id),
+        'permit_amendment_document_guid': str(amendment_document.permit_amendment_document_guid)
+    }
+
+    response = test_client.post('/mines/permits/condition-extraction', json=data, headers=auth_headers['full_auth_header'])
+    assert response.status_code == 400
+    data = response.json
+
+    assert data['message'] == '400 Bad Request: Permit conditions already exist for this permit amendment'
+    assert data['status'] == 400
+
+
+def test_post_permit_condition_fails_with_invalid_document(test_client, auth_headers, pc_test_data, db_session):
+    amendment, amendment_document = pc_test_data
+
+    data = {
+        'permit_amendment_id': uuid.uuid4(),
+        'permit_amendment_document_guid': str(amendment_document.permit_amendment_document_guid)
+    }
+
+    response = test_client.post('/mines/permits/condition-extraction', json=data, headers=auth_headers['full_auth_header'])
+    assert response.status_code == 400
+    data = response.json
+
+    assert data['message'] == '400 Bad Request: Permit document must be associated with the permit amendment'
+    assert data['status'] == 400  
+
+def test_post_permit_condition_fails_with_invalid_permit_amendment(test_client, auth_headers, db_session):
+    # Prepare the request data
+    mine, permit = create_mine_and_permit()
+
+    amendment = permit.permit_amendments[0]
+
+    data = {
+        'permit_amendment_id': str(amendment.permit_amendment_id),
+        'permit_amendment_document_guid': uuid.uuid4()
+    }
+
+    response = test_client.post('/mines/permits/condition-extraction', json=data, headers=auth_headers['full_auth_header'])
+    assert response.status_code == 400
+    data = response.json
+
+    assert data['message'] == '400 Bad Request: Permit document not found'
+    assert data['status'] == 400  
+
+@responses.activate
+@mock.patch('app.api.mines.permits.permit_extraction.resources.permit_condition_extraction_resource.poll_update_permit_extraction_status.delay')
+def test_post_permit_condition_extraction(delay, test_client, auth_headers, pc_test_data, db_session):
+    delay.return_value = mock.Mock(id='123')
+
+    amendment, amendment_document = pc_test_data
+    PermitConditions.query.filter_by(permit_amendment_id=amendment.permit_amendment_id).delete()
+    responses.add(responses.POST, f'https://test.loginproxy.gov.bc.ca/auth/realms/standard/protocol/openid-connect/token', json={'access_token':'123'})
+    responses.add(responses.GET, f'{Config.DOCUMENT_MANAGER_URL}/documents', body="abc", headers={'Content-Type': 'application/octet-stream', 'Content-Disposition': 'filename=test.pdf'}, status=200)
+    responses.add(responses.POST, f'{Config.PERMITS_ENDPOINT}/permit_conditions', json={'id': '123', 'status': 'PENDING', 'meta': {}}, status=200)
+
+    data = {
+        'permit_amendment_id': str(amendment.permit_amendment_id),
+        'permit_amendment_document_guid': str(amendment_document.permit_amendment_document_guid)
+    }
+    # Send the POST request
+    response = test_client.post('/mines/permits/condition-extraction', json=data, headers=auth_headers['full_auth_header'])
+    # Check the response status code
+    assert response.status_code == 200
+    
+    # Check the response data
+    response_data = json.loads(response.data)
+    assert 'permit_extraction_task_id' in response_data
+    assert 'core_status_task_id' in response_data
+    assert 'task_status' in response_data
+    assert response_data['task_status'] == 'PENDING'
+    
+    delay.assert_called_once_with(uuid.UUID(response_data['permit_extraction_task_id']))
+
+
+
+def test_get_permit_extraction_tasks(test_client, auth_headers, pc_test_data, db_session):
+    # Create test data
+    permit_amendment, permit_amendment_document = pc_test_data
+    task1 = PermitExtractionTask(
+        permit_extraction_task_id=uuid.uuid4(),
+        permit_amendment_guid=permit_amendment.permit_amendment_guid,
+        task_id='123',
+        task_status='PENDING',
+        task_result=None,
+        core_status_task_id='456',
+        permit_amendment_document_guid=permit_amendment_document.permit_amendment_document_guid
+    )
+
+    task2 = PermitExtractionTask(
+        permit_extraction_task_id=uuid.uuid4(),
+        permit_amendment_guid=permit_amendment.permit_amendment_guid,
+        task_id='123',
+        task_status='PENDING',
+        task_result=None,
+        core_status_task_id='456',
+        permit_amendment_document_guid=permit_amendment_document.permit_amendment_document_guid
+    )
+
+    task1.save()
+    task2.save()
+
+    # Send GET request
+    response = test_client.get(f'/mines/permits/condition-extraction?permit_amendment_id={permit_amendment.permit_amendment_id}', headers=auth_headers['full_auth_header'])
+    assert response.status_code == 200
+
+    # Check the response data
+    response_data = json.loads(response.data)
+    assert 'tasks' in response_data
+    assert len(response_data['tasks']) == 2
+    assert response_data['tasks'][1]['permit_extraction_task_id'] == str(task1.permit_extraction_task_id)
+    assert response_data['tasks'][0]['permit_extraction_task_id'] == str(task2.permit_extraction_task_id)
+
+def test_get_permit_extraction_tasks_fails_with_unknown_permit_amendment(test_client, auth_headers, db_session):
+    response = test_client.get('/mines/permits/condition-extraction?permit_amendment_id=123123', headers=auth_headers['full_auth_header'])
+    assert response.status_code == 400
+    assert response.json['message'] == '400 Bad Request: Permit amendment not found'
+
+
+def test_delete_permit_conditions(test_client, auth_headers, pc_test_data, db_session):
+    # Create test data
+    amendment, amendment_document = pc_test_data
+
+    assert PermitConditions.query.filter_by(permit_amendment_id=amendment.permit_amendment_id, deleted_ind=False).count() > 0
+
+    # Send DELETE request
+    response = test_client.delete(f'/mines/permits/condition-extraction?permit_amendment_id={amendment.permit_amendment_id}', headers=auth_headers['full_auth_header'])
+    assert response.status_code == 200
+
+    assert PermitConditions.query.filter_by(permit_amendment_id=amendment.permit_amendment_id, deleted_ind=False).count() == 0
+
+
+def test_get_permit_extraction_tasks(test_client, auth_headers, pc_test_data, db_session):
+    permit_amendment, permit_amendment_document = pc_test_data
+    task1 = PermitExtractionTask(
+        permit_extraction_task_id=uuid.uuid4(),
+        permit_amendment_guid=permit_amendment.permit_amendment_guid,
+        task_id='123',
+        task_status='PENDING',
+        task_result=None,
+        core_status_task_id='456',
+        permit_amendment_document_guid=permit_amendment_document.permit_amendment_document_guid
+    )
+
+    task2 = PermitExtractionTask(
+        permit_extraction_task_id=uuid.uuid4(),
+        permit_amendment_guid=permit_amendment.permit_amendment_guid,
+        task_id='123',
+        task_status='PENDING',
+        task_result=None,
+        core_status_task_id='456',
+        permit_amendment_document_guid=permit_amendment_document.permit_amendment_document_guid
+    )
+
+    db.session.add(task1)
+    db.session.add(task2)
+    db.session.commit()
+
+    response = test_client.get(f'/mines/permits/condition-extraction/{task1.permit_extraction_task_id}', headers=auth_headers['full_auth_header'])
+    assert response.status_code == 200
+
+    # Check the response data
+    response_data = json.loads(response.data)
+    assert response_data['permit_extraction_task_id'] == str(task1.permit_extraction_task_id)
+
+    response = test_client.get(f'/mines/permits/condition-extraction/{task2.permit_extraction_task_id}', headers=auth_headers['full_auth_header'])
+    assert response.status_code == 200
+
+    # Check the response data
+    response_data = json.loads(response.data)
+    assert response_data['permit_extraction_task_id'] == str(task2.permit_extraction_task_id)
+
+
+def test_get_permit_extraction_tasks_fails_with_unknown_permit_amendment(test_client, auth_headers, db_session):
+    response = test_client.get(f'/mines/permits/condition-extraction/{str(uuid.uuid4())}', headers=auth_headers['full_auth_header'])
+    assert response.status_code == 400
+    assert response.json['message'] == '400 Bad Request: Task not found'
\ No newline at end of file
diff --git a/services/core-api/tests/permits/permit_extraction/test_create_permit_conditions_from_task.py b/services/core-api/tests/permits/permit_extraction/test_create_permit_conditions_from_task.py
new file mode 100644
index 0000000000..33e425f961
--- /dev/null
+++ b/services/core-api/tests/permits/permit_extraction/test_create_permit_conditions_from_task.py
@@ -0,0 +1,162 @@
+import pytest
+from app.api.mines.permits.permit_conditions.models.permit_conditions import (
+    PermitConditions,
+)
+from app.api.mines.permits.permit_extraction.create_permit_conditions import (
+    create_permit_conditions_from_task,
+)
+from app.api.mines.permits.permit_extraction.models.permit_extraction_task import (
+    PermitExtractionTask,
+)
+from tests.factories import create_mine_and_permit
+
+
+@pytest.fixture(scope="function")
+def permit_amendment(test_client, db_session):
+    # Create a sample PermitExtractionTask object
+    mine, permit = create_mine_and_permit()
+    permit_amendment = permit.permit_amendments[0]
+    PermitConditions.query.delete()
+
+    yield permit_amendment
+
+
+def test_create_permit_conditions_from_task(permit_amendment, db_session):
+
+    task = PermitExtractionTask(
+        task_result={
+            "conditions": [
+                # General Section
+                {
+                    "section": "A",
+                    "paragraph": None,
+                    "subparagraph": None,
+                    "clause": None,
+                    "subclause": None,
+                    "subsubclause": None,
+                    "condition_title": None,
+                    "condition_text": "General",
+                },
+                {
+                    "section": "A",
+                    "paragraph": "1",
+                    "subparagraph": None,
+                    "clause": None,
+                    "subclause": None,
+                    "subsubclause": None,
+                    "condition_title": None,
+                    "condition_text": "This is a paragraph",
+                },
+                {
+                    "section": "A",
+                    "paragraph": "1",
+                    "subparagraph": "1",
+                    "clause": None,
+                    "subclause": None,
+                    "subsubclause": None,
+                    "condition_title": None,
+                    "condition_text": "This is a subparagraph",
+                },
+                {
+                    "section": "A",
+                    "paragraph": "1",
+                    "subparagraph": "1",
+                    "clause": 'a',
+                    "subclause": None,
+                    "subsubclause": None,
+                    "condition_title": None,
+                    "condition_text": "This is a clause",
+                },
+                {
+                    "section": "A",
+                    "paragraph": "1",
+                    "subparagraph": "1",
+                    "clause": 'a',
+                    "subclause": 'b',
+                    "subsubclause": None,
+                    "condition_title": "This condition has a title",
+                    "condition_text": "This is a subclause",
+                },
+                # Protection of Land and Watercourses Section
+                {
+                    "section": "B",
+                    "paragraph": None,
+                    "subparagraph": None,
+                    "clause": None,
+                    "subclause": None,
+                    "subsubclause": None,
+                    "condition_title": None,
+                    "condition_text": "Protection of Land and Watercourses",
+                },
+                {
+                    "section": "B",
+                    "paragraph": "2",
+                    "subparagraph": None,
+                    "clause": None,
+                    "subclause": None,
+                    "subsubclause": None,
+                    "condition_text": "Another paragraph",
+                },
+
+            ]
+        },
+        permit_amendment=permit_amendment,
+    )
+
+    # Call the function
+    create_permit_conditions_from_task(task)
+
+    # Retrieve the created permit conditions from the database
+    permit_conditions = PermitConditions.query.all()
+
+    # Assert the created permit conditions
+    assert len(permit_conditions) == 6
+
+    ### General Section
+
+    # Top level sections are not created as a PermitCondition. They are mapped to a PermitConditionCategory instead
+    assert permit_conditions[0].permit_amendment_id == permit_amendment.permit_amendment_id
+    assert permit_conditions[0].condition_category_code == "GEC"
+    assert permit_conditions[0].condition == "This is a paragraph"
+    assert permit_conditions[0].condition_type_code == "SEC" # First level is a section
+    assert permit_conditions[0].parent_permit_condition_id is None
+    assert permit_conditions[0]._step == "1"
+
+    assert permit_conditions[1].permit_amendment_id == permit_amendment.permit_amendment_id
+    assert permit_conditions[1].condition_category_code == "GEC"
+    assert permit_conditions[1].condition == "This is a subparagraph"
+    assert permit_conditions[1].condition_type_code == "CON" # Second level is a condition
+    assert permit_conditions[1].parent_permit_condition_id == permit_conditions[0].permit_condition_id
+    assert permit_conditions[1]._step == "1"
+
+    assert permit_conditions[2].permit_amendment_id == permit_amendment.permit_amendment_id
+    assert permit_conditions[2].condition_category_code == "GEC"
+    assert permit_conditions[2].condition == "This is a clause"
+    assert permit_conditions[2].condition_type_code == "LIS" # Third level on is a list item
+    assert permit_conditions[2].parent_permit_condition_id == permit_conditions[1].permit_condition_id
+    assert permit_conditions[2]._step == "a"
+
+    # When a condition both has a title and text, they are created as two conditions, with the text as a child of the title
+    # Note: This was an assumption made to make the display more accurately reflect the PDF. May need a revision.
+    assert permit_conditions[3].permit_amendment_id == permit_amendment.permit_amendment_id
+    assert permit_conditions[3].condition_category_code == "GEC"
+    assert permit_conditions[3].condition == "This condition has a title"
+    assert permit_conditions[3].condition_type_code == "LIS"
+    assert permit_conditions[3].parent_permit_condition_id == permit_conditions[2].permit_condition_id
+    assert permit_conditions[3]._step == "b"
+
+    assert permit_conditions[4].permit_amendment_id == permit_amendment.permit_amendment_id
+    assert permit_conditions[4].condition_category_code == "GEC"
+    assert permit_conditions[4].condition == "This is a subclause"
+    assert permit_conditions[4].condition_type_code == "LIS"
+    assert permit_conditions[4].parent_permit_condition_id == permit_conditions[3].permit_condition_id
+    assert permit_conditions[4]._step == "" # This is a child of the title condition - which in the PDFs do not have a step
+
+    ## Protection of Land and Watercourses Section
+
+    assert permit_conditions[5].permit_amendment_id == permit_amendment.permit_amendment_id
+    assert permit_conditions[5].condition_category_code == "ELC"
+    assert permit_conditions[5].condition == "Another paragraph"
+    assert permit_conditions[5].condition_type_code == "SEC"
+    assert permit_conditions[5].parent_permit_condition_id is None
+    assert permit_conditions[5]._step == "2"
\ No newline at end of file
diff --git a/services/core-api/tests/permits/permit_extraction/test_tasks.py b/services/core-api/tests/permits/permit_extraction/test_tasks.py
new file mode 100644
index 0000000000..3ccf20161b
--- /dev/null
+++ b/services/core-api/tests/permits/permit_extraction/test_tasks.py
@@ -0,0 +1,56 @@
+import uuid
+from unittest import mock
+
+import pytest
+from app.api.mines.permits.permit_extraction.tasks import (
+    poll_update_permit_extraction_status,
+)
+from app.tasks.celery import celery
+
+
+@pytest.fixture
+def permit_search_service_mock():
+    with mock.patch('app.api.mines.permits.permit_extraction.tasks.PermitSearchService') as mc:
+        yield mc
+
+@pytest.fixture
+def create_permit_conditions_mock():
+    with mock.patch('app.api.mines.permits.permit_extraction.tasks.create_permit_conditions_from_task') as mc:
+        yield mc
+
+@pytest.fixture(scope='module')
+def celery_app(request, app):
+    celery.conf.update(CELERY_ALWAYS_EAGER=True)
+    return app
+
+
+def test_poll_update_permit_extraction_status_success(permit_search_service_mock, celery_app, test_client, create_permit_conditions_mock, db_session):
+    permit_search_service_mock.return_value.update_task_status.return_value = mock.Mock(
+        task_status='SUCCESS'
+    )
+
+    result = poll_update_permit_extraction_status.apply(args=(str(uuid.uuid4()),)).get()
+    create_permit_conditions_mock.assert_called_once()
+
+    assert result.task_status == 'SUCCESS'
+
+
+def test_poll_update_permit_extraction_status_failure(permit_search_service_mock, celery_app, test_client, create_permit_conditions_mock, db_session):
+    permit_search_service_mock.return_value.update_task_status.return_value = mock.Mock(
+        task_status='FAILURE'
+    )
+    result = poll_update_permit_extraction_status.apply(args=(str(uuid.uuid4()),)).get()
+
+    create_permit_conditions_mock.assert_not_called()
+    assert result.task_status == 'FAILURE'
+
+
+def test_poll_update_permit_extraction_status_retry(permit_search_service_mock, celery_app, test_client, create_permit_conditions_mock, db_session):
+    permit_search_service_mock.return_value.update_task_status.return_value = mock.Mock(
+        task_status='IN_PROGRESS'
+    )
+
+    with mock.patch('app.api.mines.permits.permit_extraction.tasks.poll_update_permit_extraction_status.retry') as retry_mock:
+        poll_update_permit_extraction_status.apply(args=(str(uuid.uuid4()),)).get()
+        retry_mock.assert_called_once_with(countdown=10)
+        create_permit_conditions_mock.assert_not_called()
\ No newline at end of file
diff --git a/services/core-web/src/components/mine/Permit/PermitConditionExtraction.tsx b/services/core-web/src/components/mine/Permit/PermitConditionExtraction.tsx
new file mode 100644
index 0000000000..88e6409ad8
--- /dev/null
+++ b/services/core-web/src/components/mine/Permit/PermitConditionExtraction.tsx
@@ -0,0 +1,56 @@
+import React, { FC } from "react";
+import { Col, Row, Typography } from "antd";
+import { PERMIT } from "@/constants/assets";
+import LoadingOutlined from "@ant-design/icons/LoadingOutlined";
+
+const { Title } = Typography;
+
+export const RenderExtractionStart: FC = () => (
+  <Row align="middle" justify="space-between" gutter={[10, 16]}>
+    <Col span={24}>
+      <Title className="margin-none" level={2}>
+        Permit Conditions
+      </Title>
+    </Col>
+    <Col span={24}>
+      <Row gutter={10} style={{ background: "#fff" }} justify={"center"}>
+        <div className="null-screen fade-in" style={{ maxWidth: "1024px" }}>
+          <div>
+            <img alt="mine_img" src={PERMIT} />
+            <h3>Start extracting permit conditions</h3>
+            <p>
+              Start extracting the latest permit conditions. This process supports the ministry in
+              permit drafting and compliance by building a comprehensive condition repository,
+              adding report requirements, and making it easier to track, update, and share permit
+              conditions accross your team.
+            </p>
+          </div>
+        </div>
+      </Row>
+    </Col>
+  </Row>
+);
+
+export const RenderExtractionProgress: FC = () => (
+  <Row align="middle" justify="space-between" gutter={[10, 16]}>
+    <Col span={24}>
+      <Title className="margin-none" level={2}>
+        Permit Conditions
+      </Title>
+    </Col>
+    <Col span={24}>
+      <Row gutter={10} style={{ background: "#fff" }} justify={"center"}>
+        <div className="null-screen fade-in" style={{ maxWidth: "1024px" }}>
+          <div>
+            <LoadingOutlined style={{ fontSize: 120 }} />
+            <h3>Extracting permit conditions</h3>
+            <p>
+              We are extracing the permit conditions. This process may take anywhere from a few
+              minutes to an hour. Feel free to leave and return later to continue your work.
+            </p>
+          </div>
+        </div>
+      </Row>
+    </Col>
+  </Row>
+);
diff --git a/services/core-web/src/components/mine/Permit/PermitConditions.tsx b/services/core-web/src/components/mine/Permit/PermitConditions.tsx
index d1816d1e13..fd5ae8a8c4 100644
--- a/services/core-web/src/components/mine/Permit/PermitConditions.tsx
+++ b/services/core-web/src/components/mine/Permit/PermitConditions.tsx
@@ -17,6 +17,12 @@ import ScrollSidePageWrapper from "@mds/common/components/common/ScrollSidePageW
 import { useFeatureFlag } from "@mds/common/providers/featureFlags/useFeatureFlag";
 import { Feature } from "@mds/common/utils/featureFlag";
 import CoreButton from "@mds/common/components/common/CoreButton";
+import { LoadingOutlined } from "@ant-design/icons";
+import {
+  getPermitExtractionByGuid,
+  PermitExtractionStatus,
+} from "@mds/common/redux/slices/permitServiceSlice";
+import { RenderExtractionProgress, RenderExtractionStart } from "./PermitConditionExtraction";
 
 const { Title } = Typography;
 
@@ -33,6 +39,11 @@ const PermitConditions: FC<PermitConditionProps> = ({ latestAmendment }) => {
   const permitConditionCategoryOptions = useSelector(getPermitConditionCategoryOptions);
 
   const permitConditions = latestAmendment?.conditions;
+  const permitExtraction = useSelector(
+    getPermitExtractionByGuid(latestAmendment?.permit_amendment_id)
+  );
+
+  const fetchingPermits = useSelector((state) => state.GET_PERMITS?.isFetching);
 
   const permitConditionCategories = permitConditionCategoryOptions
     .map((cat) => {
@@ -65,6 +76,21 @@ const PermitConditions: FC<PermitConditionProps> = ({ latestAmendment }) => {
     return Promise.resolve();
   };
 
+  if (fetchingPermits) {
+    return <LoadingOutlined style={{ fontSize: 120 }} />;
+  }
+
+  const isExtractionInProgress =
+    permitExtraction?.task_status === PermitExtractionStatus.in_progress;
+  const canStartExtraction = !permitExtraction && !permitConditions?.length;
+
+  if (isExtractionInProgress) {
+    return <RenderExtractionProgress />;
+  }
+  if (canStartExtraction) {
+    return <RenderExtractionStart />;
+  }
+
   return (
     <ScrollSidePageWrapper
       header={null}
diff --git a/services/core-web/src/components/mine/Permit/ViewPermit.tsx b/services/core-web/src/components/mine/Permit/ViewPermit.tsx
index c1b8db868e..2a25746225 100644
--- a/services/core-web/src/components/mine/Permit/ViewPermit.tsx
+++ b/services/core-web/src/components/mine/Permit/ViewPermit.tsx
@@ -1,11 +1,11 @@
-import React, { FC, useEffect, useState } from "react";
+import React, { FC, useEffect, useRef, useState } from "react";
 import { useHistory, useParams } from "react-router-dom";
 import { useDispatch, useSelector } from "react-redux";
 import {
   getLatestAmendmentByPermitGuid,
   getPermitByGuid,
 } from "@mds/common/redux/selectors/permitSelectors";
-import { IMine, IPermit, IPermitAmendment } from "@mds/common";
+import { IMine, IPermit, IPermitAmendment, USER_ROLES } from "@mds/common";
 import ViewPermitOverview from "@/components/mine/Permit/ViewPermitOverview";
 import PermitConditions from "@/components/mine/Permit/PermitConditions";
 
@@ -19,6 +19,17 @@ import { Feature } from "@mds/common/utils/featureFlag";
 import { PresetStatusColorType } from "antd/es/_util/colors";
 import { Badge } from "antd";
 import { ActionMenuButton } from "@mds/common/components/common/ActionMenu";
+import {
+  getPermitExtractionByGuid,
+  initiatePermitExtraction,
+  PermitExtractionStatus,
+  fetchPermitExtractionTasks,
+  deletePermitConditions,
+  fetchPermitExtractionStatus,
+} from "@mds/common/redux/slices/permitServiceSlice";
+import { userHasRole } from "@mds/common/redux/selectors/authenticationSelectors";
+
+const tabs = ["overview", "conditions"];
 
 const ViewPermit: FC = () => {
   const dispatch = useDispatch();
@@ -29,10 +40,23 @@ const ViewPermit: FC = () => {
   const mine: IMine = useSelector((state) => getMineById(state, id));
   const { isFeatureEnabled } = useFeatureFlag();
   const enablePermitConditionsTab = isFeatureEnabled(Feature.PERMIT_CONDITIONS_PAGE);
+  const permitExtraction = useSelector(
+    getPermitExtractionByGuid(latestAmendment?.permit_amendment_id)
+  );
+
+  const userCanEditConditions = useSelector((state) =>
+    userHasRole(state, USER_ROLES.role_edit_template_conditions)
+  );
+  const documents = latestAmendment?.related_documents ?? [];
 
-  const [activeTab, setActiveTab] = useState(tab ?? "overview");
+  const [activeTab, setActiveTab] = useState(tab ?? tabs[0]);
   const history = useHistory();
 
+  const [isNewImport, setIsNewImport] = useState(false);
+
+  const statusTimerRef = useRef(null);
+  const [pollForStatus, setPollForStatus] = useState(false);
+
   useEffect(() => {
     if (!permit?.permit_id) {
       dispatch(fetchPermits(id));
@@ -45,24 +69,80 @@ const ViewPermit: FC = () => {
     }
   }, [mine]);
 
-  const canViewConditions = latestAmendment?.conditions?.length > 0;
+  useEffect(() => {
+    if (permitExtraction?.task_status === PermitExtractionStatus.complete && isNewImport) {
+      dispatch(fetchPermits(id));
+    }
+
+    if (permitExtraction?.task_status === PermitExtractionStatus.in_progress) {
+      setIsNewImport(false);
+      setPollForStatus(true);
+    } else {
+      setPollForStatus(false);
+    }
+  }, [permitExtraction?.task_status, isNewImport]);
+
+  useEffect(() => {
+    if (latestAmendment) {
+      dispatch(
+        fetchPermitExtractionTasks({ permit_amendment_id: latestAmendment.permit_amendment_id })
+      );
+    }
+  }, [latestAmendment]);
+
+  useEffect(() => {
+    const startPoll = () => {
+      statusTimerRef.current = setInterval(() => {
+        dispatch(
+          fetchPermitExtractionStatus({
+            permit_amendment_id: latestAmendment.permit_amendment_id,
+            task_id: permitExtraction.task_id,
+          })
+        );
+      }, 5000);
+    };
+
+    const stopPoll = () => {
+      if (statusTimerRef.current) {
+        clearInterval(statusTimerRef.current);
+      }
+    };
+
+    if (pollForStatus) {
+      startPoll();
+    } else {
+      stopPoll();
+    }
+
+    return () => {
+      stopPoll();
+    };
+  }, [pollForStatus, permitExtraction?.task_id]);
+
+  const hasConditions = latestAmendment?.conditions?.length > 0;
+
+  const canStartExtraction =
+    ((documents.length > 0 && !permitExtraction?.status) ||
+      [PermitExtractionStatus.error, PermitExtractionStatus.not_started].includes(
+        permitExtraction?.status
+      )) &&
+    !hasConditions;
 
   const getConditionBadge = () => {
-    const conditionStatus: PresetStatusColorType = canViewConditions ? "success" : "error";
+    const conditionStatus: PresetStatusColorType = hasConditions ? "success" : "error";
     return <Badge status={conditionStatus} />;
   };
 
   const tabItems = [
     {
-      key: "overview",
+      key: tabs[0],
       label: "Permit Overview",
       children: <ViewPermitOverview latestAmendment={latestAmendment} />,
     },
     enablePermitConditionsTab && {
-      key: "conditions",
+      key: tabs[1],
       label: <>{getConditionBadge()} Permit Conditions</>,
       children: <PermitConditions latestAmendment={latestAmendment} />,
-      disabled: !canViewConditions,
     },
   ].filter(Boolean);
 
@@ -71,15 +151,48 @@ const ViewPermit: FC = () => {
     return history.push(routes.VIEW_MINE_PERMIT.dynamicRoute(id, permitGuid, newActiveTab));
   };
 
+  const onConditionsTab = tab === tabs[1];
+
+  const handleInitiateExtraction = async () => {
+    await dispatch(
+      initiatePermitExtraction({
+        permit_amendment_id: latestAmendment?.permit_amendment_id,
+        permit_amendment_document_guid: documents[0].permit_amendment_document_guid,
+      })
+    );
+    setIsNewImport(true);
+  };
+
+  const handleDeleteConditions = async () => {
+    setIsNewImport(false);
+    await dispatch(
+      deletePermitConditions({ permit_amendment_id: latestAmendment?.permit_amendment_id })
+    );
+
+    dispatch(fetchPermits(id));
+  };
+
   const headerActions = [
-    {
-      key: "test",
-      label: "Test",
-      clickFunction: () => console.log("action not implemented", permit),
-    },
-  ];
+    onConditionsTab &&
+      userCanEditConditions && {
+        key: "extract",
+        label: "Extract Permit Conditions",
+        disabled: !canStartExtraction,
+        clickFunction: handleInitiateExtraction,
+      },
+    onConditionsTab &&
+      userCanEditConditions && {
+        key: "delete_conditions",
+        label: "Delete Permit Conditions",
+        disabled: !hasConditions,
+        clickFunction: handleDeleteConditions,
+      },
+  ].filter(Boolean);
 
-  const headerActionComponent = <ActionMenuButton actions={headerActions} />;
+  const headerActionComponent =
+    enablePermitConditionsTab && headerActions.length > 0 ? (
+      <ActionMenuButton actions={headerActions} />
+    ) : null;
 
   return (
     <div className="fixed-tabs-container">
diff --git a/services/core-web/src/components/mine/Permit/ViewPermitOverview.tsx b/services/core-web/src/components/mine/Permit/ViewPermitOverview.tsx
index e0bb8cc3c4..f934b19a09 100644
--- a/services/core-web/src/components/mine/Permit/ViewPermitOverview.tsx
+++ b/services/core-web/src/components/mine/Permit/ViewPermitOverview.tsx
@@ -250,6 +250,7 @@ const ViewPermitOverview: FC<ViewPermitOverviewProps> = ({ latestAmendment }) =>
             <Paragraph>Documents displayed here are viewable by Minespace users.</Paragraph>
             <Table
               className="margin-large--top"
+              rowKey="document_manager_guid"
               dataSource={latestAmendment.related_documents}
               columns={documentColumns}
               pagination={false}
diff --git a/services/core-web/src/tests/components/mine/Permit/__snapshots__/ViewPermit.spec.tsx.snap b/services/core-web/src/tests/components/mine/Permit/__snapshots__/ViewPermit.spec.tsx.snap
index 2864b682e3..b4a691db39 100644
--- a/services/core-web/src/tests/components/mine/Permit/__snapshots__/ViewPermit.spec.tsx.snap
+++ b/services/core-web/src/tests/components/mine/Permit/__snapshots__/ViewPermit.spec.tsx.snap
@@ -239,39 +239,6 @@ exports[`ViewPermit renders properly 1`] = `
             </div>
           </div>
         </div>
-        <div
-          class="ant-col core-header-extra"
-          style="padding-left: 8px; padding-right: 8px;"
-        >
-          <button
-            class="ant-btn ant-btn-ghost ant-dropdown-trigger actions-dropdown-button"
-            type="button"
-          >
-            <span>
-              Action
-            </span>
-            <span
-              aria-label="down"
-              class="anticon anticon-down"
-              role="img"
-            >
-              <svg
-                aria-hidden="true"
-                class=""
-                data-icon="down"
-                fill="currentColor"
-                focusable="false"
-                height="1em"
-                viewBox="64 64 896 896"
-                width="1em"
-              >
-                <path
-                  d="M884 256h-75c-5.1 0-9.9 2.5-12.9 6.6L512 654.2 227.9 262.6c-3-4.1-7.8-6.6-12.9-6.6h-75c-6.5 0-10.3 7.4-6.5 12.7l352.6 486.1c12.8 17.6 39 17.6 51.7 0l352.6-486.1c3.9-5.3.1-12.7-6.4-12.7z"
-                />
-              </svg>
-            </span>
-          </button>
-        </div>
       </div>
     </div>
     <div
@@ -310,7 +277,6 @@ exports[`ViewPermit renders properly 1`] = `
             >
               <div
                 aria-controls="rc-tabs-test-panel-conditions"
-                aria-disabled="false"
                 aria-selected="false"
                 class="ant-tabs-tab-btn"
                 id="rc-tabs-test-tab-conditions"
@@ -961,6 +927,7 @@ exports[`ViewPermit renders properly 1`] = `
                                 >
                                   <tr
                                     class="ant-table-row ant-table-row-level-0"
+                                    data-row-key="64caef0e-060d-4875-a470-6c225b242723"
                                   >
                                     <td
                                       class="ant-table-cell"
diff --git a/services/core-web/src/tests/components/mine/Permit/__snapshots__/ViewPermitOverview.spec.tsx.snap b/services/core-web/src/tests/components/mine/Permit/__snapshots__/ViewPermitOverview.spec.tsx.snap
index fcd1bf87b2..f82acb45c6 100644
--- a/services/core-web/src/tests/components/mine/Permit/__snapshots__/ViewPermitOverview.spec.tsx.snap
+++ b/services/core-web/src/tests/components/mine/Permit/__snapshots__/ViewPermitOverview.spec.tsx.snap
@@ -579,6 +579,7 @@ exports[`MinePermitInfo renders properly 1`] = `
                     >
                       <tr
                         class="ant-table-row ant-table-row-level-0"
+                        data-row-key="64caef0e-060d-4875-a470-6c225b242723"
                       >
                         <td
                           class="ant-table-cell"
diff --git a/services/document-manager/backend/celery.sh b/services/document-manager/backend/celery.sh
index b6e596dc19..5dd2a323c7 100755
--- a/services/document-manager/backend/celery.sh
+++ b/services/document-manager/backend/celery.sh
@@ -2,6 +2,6 @@
 
 cd /app
 
-celery -A app.tasks.celery worker --detach --loglevel=info --logfile=/tmp/celery/celery.log --pidfile=/tmp/celery/celery.pid --concurrency=1
+celery -A app.tasks.celery worker --loglevel=info --logfile=/tmp/celery/celery.log --pidfile=/tmp/celery/celery.pid --concurrency=1
 
-celery -A app.tasks.celery flower --basic_auth=${FLOWER_USER}:${FLOWER_USER_PASSWORD}
\ No newline at end of file
+celery -A app.tasks.celery flower --detach --basic_auth=${FLOWER_USER}:${FLOWER_USER_PASSWORD}
\ No newline at end of file
diff --git a/services/permits/tests/test_tasks.py b/services/permits/tests/test_tasks.py
deleted file mode 100644
index e148e3db39..0000000000
--- a/services/permits/tests/test_tasks.py
+++ /dev/null
@@ -1,18 +0,0 @@
-import os
-from unittest import mock
-
-import pytest
-from app.permit_conditions.context import context
-from app.permit_conditions.tasks.tasks import task_context
-
-
-def test_task_context():
-    task = mock.Mock()
-
-    with task_context(task):
-        # Assert that the task is set in the context
-        assert task == context.get()
-
-    # Assert that the task is reset after exiting the context
-    with pytest.raises(LookupError):
-        context.get()