660 lines
16 KiB
TypeScript
660 lines
16 KiB
TypeScript
import { defineStore } from "pinia";
|
|
import { ref, computed } from "vue";
|
|
import InterventionService from "@/services/intervention";
|
|
import type {
|
|
Intervention,
|
|
CreateInterventionPayload,
|
|
UpdateInterventionPayload,
|
|
InterventionListResponse,
|
|
} from "@/services/intervention";
|
|
|
|
export const useInterventionStore = defineStore("intervention", () => {
|
|
// State
|
|
const interventions = ref<Intervention[]>([]);
|
|
const currentIntervention = ref<Intervention | null>(null);
|
|
const loading = ref(false);
|
|
const error = ref<string | null>(null);
|
|
const success = ref(false);
|
|
|
|
// Pagination state
|
|
const pagination = ref({
|
|
current_page: 1,
|
|
last_page: 1,
|
|
per_page: 10,
|
|
total: 0,
|
|
});
|
|
|
|
// Getters
|
|
const allInterventions = computed(() => interventions.value);
|
|
|
|
const isLoading = computed(() => loading.value);
|
|
const hasError = computed(() => error.value !== null);
|
|
const getError = computed(() => error.value);
|
|
const isSuccess = computed(() => success.value);
|
|
|
|
const getInterventionById = computed(() => (id: number) =>
|
|
interventions.value.find((i) => i.id === id)
|
|
);
|
|
|
|
const getPagination = computed(() => pagination.value);
|
|
|
|
const getInterventionsByDeceased = computed(() => (deceasedId: number) =>
|
|
interventions.value.filter((i) => i.deceased_id === deceasedId)
|
|
);
|
|
|
|
const getInterventionsByClient = computed(() => (clientId: number) =>
|
|
interventions.value.filter((i) => i.client_id === clientId)
|
|
);
|
|
|
|
const getScheduledInterventions = computed(() =>
|
|
interventions.value.filter(
|
|
(i) => i.scheduled_at && new Date(i.scheduled_at) > new Date()
|
|
)
|
|
);
|
|
|
|
const getCompletedInterventions = computed(() =>
|
|
interventions.value.filter((i) => i.status === "completed")
|
|
);
|
|
|
|
const getPendingInterventions = computed(() =>
|
|
interventions.value.filter((i) => i.status === "pending")
|
|
);
|
|
|
|
// Actions
|
|
const setLoading = (isLoading: boolean) => {
|
|
loading.value = isLoading;
|
|
};
|
|
|
|
const setError = (err: string | null) => {
|
|
error.value = err;
|
|
};
|
|
|
|
const clearError = () => {
|
|
error.value = null;
|
|
};
|
|
|
|
const setSuccess = (isSuccess: boolean) => {
|
|
success.value = isSuccess;
|
|
};
|
|
|
|
const clearSuccess = () => {
|
|
success.value = false;
|
|
};
|
|
|
|
const setInterventions = (newInterventions: Intervention[]) => {
|
|
interventions.value = newInterventions;
|
|
};
|
|
|
|
const setCurrentIntervention = (intervention: Intervention | null) => {
|
|
currentIntervention.value = intervention;
|
|
};
|
|
|
|
const setPagination = (meta: any) => {
|
|
if (meta) {
|
|
pagination.value = {
|
|
current_page: meta.current_page || 1,
|
|
last_page: meta.last_page || 1,
|
|
per_page: meta.per_page || 10,
|
|
total: meta.total || 0,
|
|
};
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get all interventions with pagination and filters
|
|
*/
|
|
const fetchInterventions = async (params?: {
|
|
page?: number;
|
|
per_page?: number;
|
|
search?: string;
|
|
deceased_id?: number;
|
|
client_id?: number;
|
|
status?: string;
|
|
scheduled_at?: string;
|
|
sort_by?: string;
|
|
sort_order?: "asc" | "desc";
|
|
}) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const response = await InterventionService.getAllInterventions(params);
|
|
setInterventions(response.data);
|
|
if (response.meta) {
|
|
setPagination(response.meta);
|
|
}
|
|
return response;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec du chargement des interventions";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get a single intervention by ID
|
|
*/
|
|
const fetchInterventionById = async (id: number) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const intervention = await InterventionService.getIntervention(id);
|
|
console.log(intervention);
|
|
setCurrentIntervention(intervention);
|
|
return intervention;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec du chargement de l'intervention";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Create a new intervention
|
|
*/
|
|
const createIntervention = async (payload: CreateInterventionPayload) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const intervention = await InterventionService.createIntervention(
|
|
payload
|
|
);
|
|
// Add the new intervention to the list
|
|
interventions.value.unshift(intervention);
|
|
setCurrentIntervention(intervention);
|
|
setSuccess(true);
|
|
return intervention;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec de la création de l'intervention";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Create a new intervention with all data (deceased, client, location, documents)
|
|
*/
|
|
const createInterventionWithAllData = async (formData: FormData) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const intervention = await InterventionService.createInterventionWithAllData(
|
|
formData
|
|
);
|
|
// Add the new intervention to the list
|
|
interventions.value.unshift(intervention);
|
|
setCurrentIntervention(intervention);
|
|
setSuccess(true);
|
|
return intervention;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec de la création de l'intervention avec toutes les données";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Update an existing intervention
|
|
*/
|
|
const updateIntervention = async (payload: UpdateInterventionPayload) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const intervention = await InterventionService.updateIntervention(
|
|
payload
|
|
);
|
|
|
|
// Update in the interventions list
|
|
const index = interventions.value.findIndex(
|
|
(i) => i.id === intervention.id
|
|
);
|
|
if (index !== -1) {
|
|
interventions.value[index] = intervention;
|
|
}
|
|
|
|
// Update current intervention if it's the one being edited
|
|
if (
|
|
currentIntervention.value &&
|
|
currentIntervention.value.id === intervention.id
|
|
) {
|
|
setCurrentIntervention(intervention);
|
|
}
|
|
|
|
setSuccess(true);
|
|
return intervention;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec de la mise à jour de l'intervention";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Delete an intervention
|
|
*/
|
|
const deleteIntervention = async (id: number) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const response = await InterventionService.deleteIntervention(id);
|
|
|
|
// Remove from the interventions list
|
|
interventions.value = interventions.value.filter((i) => i.id !== id);
|
|
|
|
// Clear current intervention if it's the one being deleted
|
|
if (currentIntervention.value && currentIntervention.value.id === id) {
|
|
setCurrentIntervention(null);
|
|
}
|
|
|
|
return response;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec de la suppression de l'intervention";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get interventions by deceased ID
|
|
*/
|
|
const fetchInterventionsByDeceased = async (
|
|
deceasedId: number,
|
|
params?: {
|
|
page?: number;
|
|
per_page?: number;
|
|
}
|
|
) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const response = await InterventionService.getInterventionsByDeceased(
|
|
deceasedId,
|
|
params
|
|
);
|
|
setInterventions(response.data);
|
|
if (response.meta) {
|
|
setPagination(response.meta);
|
|
}
|
|
return response;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec du chargement des interventions du défunt";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get interventions by client ID
|
|
*/
|
|
const fetchInterventionsByClient = async (
|
|
clientId: number,
|
|
params?: {
|
|
page?: number;
|
|
per_page?: number;
|
|
}
|
|
) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const response = await InterventionService.getInterventionsByClient(
|
|
clientId,
|
|
params
|
|
);
|
|
setInterventions(response.data);
|
|
if (response.meta) {
|
|
setPagination(response.meta);
|
|
}
|
|
return response;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec du chargement des interventions du client";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Search interventions by various criteria
|
|
*/
|
|
const searchInterventions = async (
|
|
query: string,
|
|
params?: {
|
|
exact_match?: boolean;
|
|
}
|
|
) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const results = await InterventionService.searchInterventions(
|
|
query,
|
|
params
|
|
);
|
|
setInterventions(results);
|
|
return results;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec de la recherche d'interventions";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Update intervention status
|
|
*/
|
|
const updateInterventionStatus = async (id: number, status: string) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const intervention = await InterventionService.updateInterventionStatus(
|
|
id,
|
|
status
|
|
);
|
|
|
|
// Update in the interventions list
|
|
const index = interventions.value.findIndex(
|
|
(i) => i.id === intervention.id
|
|
);
|
|
if (index !== -1) {
|
|
interventions.value[index] = intervention;
|
|
}
|
|
|
|
// Update current intervention if it's the one being updated
|
|
if (
|
|
currentIntervention.value &&
|
|
currentIntervention.value.id === intervention.id
|
|
) {
|
|
setCurrentIntervention(intervention);
|
|
}
|
|
|
|
setSuccess(true);
|
|
return intervention;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec de la mise à jour du statut";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Assign practitioner(s) to intervention
|
|
*/
|
|
const assignPractitioner = async (
|
|
id: number,
|
|
practitionerData: {
|
|
practitioners?: number[];
|
|
principal_practitioner_id?: number;
|
|
assistant_practitioner_ids?: number[];
|
|
}
|
|
) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const intervention = await InterventionService.assignPractitioner(
|
|
id,
|
|
practitionerData
|
|
);
|
|
|
|
// Update in the interventions list
|
|
const index = interventions.value.findIndex(
|
|
(i) => i.id === intervention.id
|
|
);
|
|
if (index !== -1) {
|
|
interventions.value[index] = intervention;
|
|
}
|
|
|
|
// Update current intervention if it's the one being updated
|
|
if (
|
|
currentIntervention.value &&
|
|
currentIntervention.value.id === intervention.id
|
|
) {
|
|
setCurrentIntervention(intervention);
|
|
}
|
|
|
|
setSuccess(true);
|
|
return intervention;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec de l'assignation des praticiens";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Assign multiple practitioners to intervention
|
|
*/
|
|
const assignPractitioners = async (
|
|
id: number,
|
|
practitionerIds: number[],
|
|
principalPractitionerId?: number
|
|
) => {
|
|
return assignPractitioner(id, {
|
|
practitioners: practitionerIds,
|
|
principal_practitioner_id: principalPractitionerId,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Update practitioners for intervention (replace all existing)
|
|
*/
|
|
const updatePractitioners = async (
|
|
id: number,
|
|
practitionerData: {
|
|
practitioners?: number[];
|
|
principal_practitioner_id?: number;
|
|
assistant_practitioner_ids?: number[];
|
|
}
|
|
) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const intervention = await InterventionService.updatePractitioners(
|
|
id,
|
|
practitionerData
|
|
);
|
|
|
|
// Update in the interventions list
|
|
const index = interventions.value.findIndex(
|
|
(i) => i.id === intervention.id
|
|
);
|
|
if (index !== -1) {
|
|
interventions.value[index] = intervention;
|
|
}
|
|
|
|
// Update current intervention if it's the one being updated
|
|
if (
|
|
currentIntervention.value &&
|
|
currentIntervention.value.id === intervention.id
|
|
) {
|
|
setCurrentIntervention(intervention);
|
|
}
|
|
|
|
setSuccess(true);
|
|
return intervention;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec de la mise à jour des praticiens";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get interventions by month
|
|
*/
|
|
const fetchInterventionsByMonth = async (year: number, month: number) => {
|
|
setLoading(true);
|
|
setError(null);
|
|
setSuccess(false);
|
|
|
|
try {
|
|
const response = await InterventionService.getInterventionsByMonth(
|
|
year,
|
|
month
|
|
);
|
|
setInterventions(response.data);
|
|
if (response.meta) {
|
|
setPagination(response.meta);
|
|
}
|
|
return response;
|
|
} catch (err: any) {
|
|
const errorMessage =
|
|
err.response?.data?.message ||
|
|
err.message ||
|
|
"Échec du chargement des interventions du mois";
|
|
setError(errorMessage);
|
|
throw err;
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Reset the state
|
|
*/
|
|
const resetState = () => {
|
|
interventions.value = [];
|
|
currentIntervention.value = null;
|
|
loading.value = false;
|
|
error.value = null;
|
|
success.value = false;
|
|
pagination.value = {
|
|
current_page: 1,
|
|
last_page: 1,
|
|
per_page: 10,
|
|
total: 0,
|
|
};
|
|
};
|
|
|
|
return {
|
|
// State
|
|
interventions,
|
|
currentIntervention,
|
|
loading,
|
|
error,
|
|
success,
|
|
pagination,
|
|
|
|
// Getters
|
|
allInterventions,
|
|
isLoading,
|
|
hasError,
|
|
getError,
|
|
isSuccess,
|
|
getInterventionById,
|
|
getPagination,
|
|
getInterventionsByDeceased,
|
|
getInterventionsByClient,
|
|
getScheduledInterventions,
|
|
getCompletedInterventions,
|
|
getPendingInterventions,
|
|
|
|
// Actions
|
|
setLoading,
|
|
setError,
|
|
clearError,
|
|
setSuccess,
|
|
clearSuccess,
|
|
setInterventions,
|
|
setCurrentIntervention,
|
|
setPagination,
|
|
fetchInterventions,
|
|
fetchInterventionById,
|
|
createIntervention,
|
|
createInterventionWithAllData,
|
|
updateIntervention,
|
|
deleteIntervention,
|
|
fetchInterventionsByDeceased,
|
|
fetchInterventionsByClient,
|
|
searchInterventions,
|
|
updateInterventionStatus,
|
|
assignPractitioner,
|
|
assignPractitioners,
|
|
updatePractitioners,
|
|
fetchInterventionsByMonth,
|
|
resetState,
|
|
};
|
|
});
|
|
|
|
export default useInterventionStore;
|