WhiteNightsAdminPanel/src/shared/store/VehicleStore/index.ts

import { languageInstance } from "@shared";
import { makeAutoObservable, runInAction } from "mobx";

export type Vehicle = {
  vehicle: {
    id: number;
    tail_number: string;
    type: number;
    carrier_id: number;
    carrier: string;
    uuid?: string;
    model?: string;
    current_snapshot_uuid?: string;
    snapshot_update_blocked?: boolean;
  };
  device_status?: {
    device_uuid: string;
    online: boolean;
    gps_ok: boolean;
    media_service_ok: boolean;
    last_update: string;
    is_connected: boolean;
  };
};

class VehicleStore {
  vehicles: {
    data: Vehicle[];
    loaded: boolean;
  } = {
    data: [],
    loaded: false,
  };
  vehicle: Record<string, Vehicle> = {};

  constructor() {
    makeAutoObservable(this);
  }

  getVehicles = async () => {
    const response = await languageInstance("ru").get(`/vehicle`);

    runInAction(() => {
      this.vehicles.data = response.data;
      this.vehicles.loaded = true;
    });
  };

  deleteVehicle = async (id: number) => {
    await languageInstance("ru").delete(`/vehicle/${id}`);

    runInAction(() => {
      this.vehicles.data = this.vehicles.data.filter(
        (vehicle) => vehicle.vehicle.id !== id
      );
    });
  };

  getVehicle = async (id: number) => {
    const response = await languageInstance("ru").get(`/vehicle/${id}`);

    runInAction(() => {
      this.vehicle[id] = response.data;
    });
  };

  createVehicle = async (
    tailNumber: string,
    type: number,
    carrier: string,
    carrierId: number,
    model?: string
  ) => {
    const payload: Record<string, unknown> = {
      tail_number: tailNumber,
      type,
      carrier,
      carrier_id: carrierId,
    };
    // TODO: когда будет бекенд — добавить model в payload и в ответ
    if (model != null && model !== "") payload.model = model;
    const response = await languageInstance("ru").post("/vehicle", payload);

    runInAction(() => {
      this.vehicles.data.push({
        vehicle: {
          id: response.data.id,
          tail_number: response.data.tail_number,
          type: response.data.type,
          carrier_id: response.data.carrier_id,
          carrier: response.data.carrier,
          uuid: response.data.uuid,
          model: response.data.model ?? model,
        },
      });
    });
  };

  editVehicleData: {
    tail_number: string;
    type: number;
    carrier: string;
    carrier_id: number;
    model: string;
    snapshot_update_blocked: boolean;
  } = {
    tail_number: "",
    type: 0,
    carrier: "",
    carrier_id: 0,
    model: "",
    snapshot_update_blocked: false,
  };

  setEditVehicleData = (data: {
    tail_number: string;
    type: number;
    carrier: string;
    carrier_id: number;
    model?: string;
    snapshot_update_blocked?: boolean;
  }) => {
    this.editVehicleData = {
      ...this.editVehicleData,
      ...data,
    };
  };

  editVehicle = async (
    id: number,
    data: {
      tail_number: string;
      type: number;
      carrier: string;
      carrier_id: number;
      model?: string;
      snapshot_update_blocked?: boolean;
    }
  ) => {
    const payload: Record<string, unknown> = {
      tail_number: data.tail_number,
      type: data.type,
      carrier: data.carrier,
      carrier_id: data.carrier_id,
    };
    if (data.model != null && data.model !== "") payload.model = data.model;
    if (data.snapshot_update_blocked != null)
      payload.snapshot_update_blocked = data.snapshot_update_blocked;
    const response = await languageInstance("ru").patch(
      `/vehicle/${id}`,
      payload
    );

    runInAction(() => {
      const updated = {
        ...response.data,
        model: response.data.model ?? data.model,
        snapshot_update_blocked:
          response.data.snapshot_update_blocked ?? data.snapshot_update_blocked,
      };
      this.vehicle[id] = {
        vehicle: {
          ...this.vehicle[id].vehicle,
          ...updated,
        },
      };
      this.vehicles.data = this.vehicles.data.map((vehicle) =>
        vehicle.vehicle.id === id
          ? {
              ...vehicle,
              vehicle: {
                ...vehicle.vehicle,
                ...updated,
              },
            }
          : vehicle
      );
    });
  };
}

export const vehicleStore = new VehicleStore();