KRBL/WhiteNightsAdminPanel
10
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: KRBL:9bf294e124e3d3ae658575c630b8dc6e12262b50
Branches Tags
KRBL:master
KRBL:react
...
compare: KRBL:544012689877ee212cb62d1983668b1b511d6c77
Branches Tags
KRBL:react
KRBL:master

4 Commits
9bf294e124 ... 5440126898

Author SHA1 Message Date
itoshi
5440126898 fix: Fix bug with route preview
All checks were successful
release-tag / release-image (push) Successful in 2m28s
Details
2025-05-28 11:31:37 +03:00
itoshi
a6a5288262 fix: Fix for correct usage 2025-05-28 11:08:28 +03:00
itoshi
b837aae711 feat: Add language switcher for preview route 2025-05-27 20:57:14 +03:00
itoshi
ede6681c28 feat: Update css file 2025-05-27 03:43:46 +03:00
25 changed files with 1396 additions and 970 deletions
Show Stats Expand all files Collapse all files

6
index.html
View File

@ -2,7 +2,7 @@
<html lang="en"> <html lang="en">
<head> <head>
<meta charset="utf-8" /> <meta charset="utf-8" />
<link rel="icon" href="/favicon.ico" /> <link rel="icon" type="image/png" href="/favicon-ship.png" />
<meta name="viewport" content="width=device-width, initial-scale=1" /> <meta name="viewport" content="width=device-width, initial-scale=1" />
<meta name="theme-color" content="#000000" /> <meta name="theme-color" content="#000000" />
<meta <meta
@ -19,9 +19,7 @@
name="twitter:image" name="twitter:image"
content="https://refine.dev/img/refine_social.png" content="https://refine.dev/img/refine_social.png"
/> />
<title> <title>Белые ночи</title>
Белые ночи
</title>
</head> </head>
<body> <body>
<noscript>You need to enable JavaScript to run this app.</noscript> <noscript>You need to enable JavaScript to run this app.</noscript>

BIN
public/favicon-ship.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.8 KiB

7
src/components/LinkedItems.tsx
View File

@ -70,6 +70,7 @@ type LinkedItemsProps<T> = {
disableCreation?: boolean; disableCreation?: boolean;
updatedLinkedItems?: T[]; updatedLinkedItems?: T[];
refresh?: number; refresh?: number;
cityId?: number;
}; };
const reorder = (list: any[], startIndex: number, endIndex: number) => { const reorder = (list: any[], startIndex: number, endIndex: number) => {
@ -131,6 +132,7 @@ export const LinkedItemsContents = <
disableCreation = false, disableCreation = false,
updatedLinkedItems, updatedLinkedItems,
refresh, refresh,
cityId,
}: LinkedItemsProps<T>) => { }: LinkedItemsProps<T>) => {
const { language } = languageStore; const { language } = languageStore;
const { setArticleModalOpenAction, setArticleIdAction } = articleStore; const { setArticleModalOpenAction, setArticleIdAction } = articleStore;
@ -216,7 +218,7 @@ export const LinkedItemsContents = <
useEffect(() => { useEffect(() => {
if (type === "edit") { if (type === "edit") {
axiosInstance axiosInstance
.get(`${import.meta.env.VITE_KRBL_API}/${childResource}/`) .get(`${import.meta.env.VITE_KRBL_API}/${childResource}/`, {})
.then((response) => { .then((response) => {
setItems(response?.data || []); setItems(response?.data || []);
setIsLoading(false); setIsLoading(false);
@ -445,7 +447,7 @@ export const LinkedItemsContents = <
availableItems?.find((item) => item.id === selectedItemId) || null availableItems?.find((item) => item.id === selectedItemId) || null
} }
onChange={(_, newValue) => setSelectedItemId(newValue?.id || null)} onChange={(_, newValue) => setSelectedItemId(newValue?.id || null)}
options={availableItems} options={availableItems.filter((item) => item.city_id == cityId)}
getOptionLabel={(item) => String(item[fields[0].data])} getOptionLabel={(item) => String(item[fields[0].data])}
renderInput={(params) => ( renderInput={(params) => (
<TextField {...params} label={`Выберите ${title}`} fullWidth /> <TextField {...params} label={`Выберите ${title}`} fullWidth />
@ -456,6 +458,7 @@ export const LinkedItemsContents = <
.toLowerCase() .toLowerCase()
.split(" ") .split(" ")
.filter((word) => word.length > 0); .filter((word) => word.length > 0);
return options.filter((option) => { return options.filter((option) => {
const optionWords = String(option[fields[0].data]) const optionWords = String(option[fields[0].data])
.toLowerCase() .toLowerCase()

11
src/components/header/index.tsx
View File

@ -143,8 +143,17 @@ export const Header: React.FC<RefineThemedLayoutV2HeaderProps> = observer(
justifyContent="flex-end" justifyContent="flex-end"
alignItems="center" alignItems="center"
spacing={2} spacing={2}
color="white"
sx={{
"& .MuiSelect-select": {
color: "white",
},
}}
> >
<FormControl variant="standard" sx={{ width: "min-content" }}> <FormControl
variant="standard"
sx={{ width: "min-content", color: "white" }}
>
{city_id && cities && ( {city_id && cities && (
<Select <Select
defaultValue={city_id} defaultValue={city_id}

2
src/components/modals/StationEditModal/index.tsx
View File

@ -121,7 +121,7 @@ export const StationEditModal = observer(() => {
> >
<Box sx={style}> <Box sx={style}>
<Edit <Edit
title={<Typography variant="h5">Редактирование станции</Typography>} title={<Typography variant="h5">Редактирование остановки</Typography>}
saveButtonProps={saveButtonProps} saveButtonProps={saveButtonProps}
> >
<Box <Box

17
src/components/ui/SidebarTitle.tsx
View File

@ -1,11 +1,16 @@
import {ProjectIcon} from './Icons' import { Ship } from "lucide-react";
import { ProjectIcon } from "./Icons";
export default function SidebarTitle({collapsed}: {collapsed: boolean}) { export default function SidebarTitle({ collapsed }: { collapsed: boolean }) {
return ( return (
<div style={{display: 'flex', alignItems: 'center', whiteSpace: 'nowrap'}}> <div
<ProjectIcon style={{color: '#7f6b58'}} /> style={{ display: "flex", alignItems: "center", whiteSpace: "nowrap" }}
>
<Ship size={40} style={{ color: "#7f6b58" }} />
{!collapsed && <span style={{marginLeft: 8, fontWeight: 'bold'}}>Белые ночи</span>} {!collapsed && (
<span style={{ marginLeft: 8, fontWeight: "bold" }}>Белые ночи</span>
)}
</div> </div>
) );
} }

8
src/globals.css
View File

@ -14,12 +14,12 @@
cursor: pointer; cursor: pointer;
padding: 0; padding: 0;
margin: 0; margin: 0;
width: 35px; width: 32px;
height: 35px; height: 32px;
color: #544044; color: rgba(79, 138, 95, 1);
border-radius: 10%; border-radius: 10%;
transition: all 0.3s ease; transition: all 0.3s ease;
} }
.backup-button:hover { .backup-button:hover {
background-color: rgba(84, 64, 68, 0.5); background-color: rgba(79, 138, 95, 0.05);
} }

6
src/locales/ru/translation.json
View File

@ -94,9 +94,9 @@
}, },
"station": { "station": {
"titles": { "titles": {
"create": "Создать станцию", "create": "Создать остановку",
"edit": "Редактировать станцию", "edit": "Редактировать остановку",
"show": "Показать станцию" "show": "Показать остановку"
} }
}, },
"snapshots": { "snapshots": {

387
src/pages/route-preview/InfiniteCanvas.tsx
View File

@ -1,179 +1,230 @@
import { FederatedMouseEvent, FederatedWheelEvent } from "pixi.js"; import { FederatedMouseEvent, FederatedWheelEvent } from "pixi.js";
import { Component, ReactNode, useEffect, useState } from "react"; import { Component, ReactNode, useEffect, useState, useRef } from "react";
import { useTransform } from "./TransformContext"; import { useTransform } from "./TransformContext";
import { useMapData } from "./MapDataContext"; import { useMapData } from "./MapDataContext";
import { SCALE_FACTOR } from "./Constants"; import { SCALE_FACTOR } from "./Constants";
import { useApplication } from "@pixi/react"; import { useApplication } from "@pixi/react";
class ErrorBoundary extends Component<{ children: ReactNode }, { hasError: boolean }> { class ErrorBoundary extends Component<
state = { hasError: false }; { children: ReactNode },
{ hasError: boolean }
> {
state = { hasError: false };
static getDerivedStateFromError() { static getDerivedStateFromError() {
return { hasError: true }; return { hasError: true };
}
componentDidCatch(error: Error, info: React.ErrorInfo) {
console.error("Error caught:", error, info);
}
render() {
return this.state.hasError ? <p>Whoopsie Daisy!</p> : this.props.children;
}
} }
componentDidCatch(error: Error, info: React.ErrorInfo) {
console.error("Error caught:", error, info);
}
export function InfiniteCanvas({children} : Readonly<{children?: ReactNode}>) { render() {
const { position, setPosition, scale, setScale, rotation, setRotation, setScreenCenter, screenCenter } = useTransform(); return this.state.hasError ? <p>Whoopsie Daisy!</p> : this.props.children;
const { routeData, originalRouteData } = useMapData(); }
}
const applicationRef = useApplication();
export function InfiniteCanvas({
const [isDragging, setIsDragging] = useState(false); children,
const [startMousePosition, setStartMousePosition] = useState({ x: 0, y: 0 }); }: Readonly<{ children?: ReactNode }>) {
const [startRotation, setStartRotation] = useState(0); const {
const [startPosition, setStartPosition] = useState({ x: 0, y: 0 }); position,
setPosition,
useEffect(() => { scale,
const canvas = applicationRef?.app.canvas; setScale,
if (!canvas) return; rotation,
const canvasRect = canvas.getBoundingClientRect(); setRotation,
const canvasLeft = canvasRect?.left ?? 0; setScreenCenter,
const canvasTop = canvasRect?.top ?? 0; screenCenter,
const centerX = window.innerWidth / 2 - canvasLeft; } = useTransform();
const centerY = window.innerHeight / 2 - canvasTop; const { routeData, originalRouteData } = useMapData();
setScreenCenter({x: centerX, y: centerY});
}, [applicationRef?.app.canvas, window.innerWidth, window.innerHeight]); const applicationRef = useApplication();
const handlePointerDown = (e: FederatedMouseEvent) => { const [isDragging, setIsDragging] = useState(false);
setIsDragging(true); const [startMousePosition, setStartMousePosition] = useState({ x: 0, y: 0 });
setStartPosition({ const [startRotation, setStartRotation] = useState(0);
x: position.x, const [startPosition, setStartPosition] = useState({ x: 0, y: 0 });
y: position.y
}); // Флаг для предотвращения конфликта между пользовательским вводом и данными маршрута
setStartMousePosition({ const [isUserInteracting, setIsUserInteracting] = useState(false);
x: e.globalX,
y: e.globalY // Реф для отслеживания последнего значения originalRouteData?.rotate
}); const lastOriginalRotation = useRef<number | undefined>(undefined);
setStartRotation(rotation);
e.stopPropagation(); useEffect(() => {
}; const canvas = applicationRef?.app.canvas;
if (!canvas) return;
useEffect(() => { const canvasRect = canvas.getBoundingClientRect();
setRotation((originalRouteData?.rotate ?? 0) * Math.PI / 180); const canvasLeft = canvasRect.left;
}, [originalRouteData?.rotate]); const canvasTop = canvasRect.top;
// Get canvas element and its dimensions/position const centerX = window.innerWidth / 2 - canvasLeft;
const handlePointerMove = (e: FederatedMouseEvent) => { const centerY = window.innerHeight / 2 - canvasTop;
if (!isDragging) return; setScreenCenter({ x: centerX, y: centerY });
}, [applicationRef?.app.canvas, setScreenCenter]);
if (e.shiftKey) {
const center = screenCenter ?? {x: 0, y: 0}; const handlePointerDown = (e: FederatedMouseEvent) => {
const startAngle = Math.atan2(startMousePosition.y - center.y, startMousePosition.x - center.x); setIsDragging(true);
const currentAngle = Math.atan2(e.globalY - center.y, e.globalX - center.x); setIsUserInteracting(true); // Устанавливаем флаг взаимодействия пользователя
setStartPosition({
// Calculate rotation difference in radians x: position.x,
const rotationDiff = currentAngle - startAngle; y: position.y,
});
// Update rotation setStartMousePosition({
setRotation(startRotation + rotationDiff); x: e.globalX,
y: e.globalY,
const cosDelta = Math.cos(rotationDiff); });
const sinDelta = Math.sin(rotationDiff); setStartRotation(rotation);
e.stopPropagation();
setPosition({ };
x: center.x * (1 - cosDelta) + startPosition.x * cosDelta + (center.y - startPosition.y) * sinDelta,
y: center.y * (1 - cosDelta) + startPosition.y * cosDelta + (startPosition.x - center.x) * sinDelta // Устанавливаем rotation только при изменении originalRouteData и отсутствии взаимодействия пользователя
}); useEffect(() => {
const newRotation = originalRouteData?.rotate ?? 0;
} else {
setRotation(startRotation); // Обновляем rotation только если:
setPosition({ // 1. Пользователь не взаимодействует с канвасом
x: startPosition.x - startMousePosition.x + e.globalX, // 2. Значение действительно изменилось
y: startPosition.y - startMousePosition.y + e.globalY if (!isUserInteracting && lastOriginalRotation.current !== newRotation) {
}); setRotation((newRotation * Math.PI) / 180);
} lastOriginalRotation.current = newRotation;
e.stopPropagation(); }
}; }, [originalRouteData?.rotate, isUserInteracting, setRotation]);
// Handle mouse up const handlePointerMove = (e: FederatedMouseEvent) => {
const handlePointerUp = (e: FederatedMouseEvent) => { if (!isDragging) return;
setIsDragging(false);
e.stopPropagation(); if (e.shiftKey) {
}; const center = screenCenter ?? { x: 0, y: 0 };
// Handle mouse wheel for zooming const startAngle = Math.atan2(
const handleWheel = (e: FederatedWheelEvent) => { startMousePosition.y - center.y,
e.stopPropagation(); startMousePosition.x - center.x
);
// Get mouse position relative to canvas const currentAngle = Math.atan2(
const mouseX = e.globalX - position.x; e.globalY - center.y,
const mouseY = e.globalY - position.y; e.globalX - center.x
);
// Calculate new scale
const scaleMin = (routeData?.scale_min ?? 10)/SCALE_FACTOR; // Calculate rotation difference in radians
const scaleMax = (routeData?.scale_max ?? 20)/SCALE_FACTOR; const rotationDiff = currentAngle - startAngle;
let zoomFactor = e.deltaY > 0 ? 0.9 : 1.1; // Zoom out/in // Update rotation
//const newScale = scale * zoomFactor; setRotation(startRotation + rotationDiff);
const newScale = Math.max(scaleMin, Math.min(scaleMax, scale * zoomFactor));
zoomFactor = newScale / scale; const cosDelta = Math.cos(rotationDiff);
const sinDelta = Math.sin(rotationDiff);
if (scale === newScale) {
return; setPosition({
} x:
center.x * (1 - cosDelta) +
// Update position to zoom towards mouse cursor startPosition.x * cosDelta +
setPosition({ (center.y - startPosition.y) * sinDelta,
x: position.x + mouseX * (1 - zoomFactor), y:
y: position.y + mouseY * (1 - zoomFactor) center.y * (1 - cosDelta) +
}); startPosition.y * cosDelta +
(startPosition.x - center.x) * sinDelta,
setScale(newScale); });
}; } else {
setRotation(startRotation);
useEffect(() => { setPosition({
applicationRef?.app.render(); x: startPosition.x - startMousePosition.x + e.globalX,
console.log(position, scale, rotation); y: startPosition.y - startMousePosition.y + e.globalY,
}, [position, scale, rotation]); });
}
e.stopPropagation();
return ( };
<ErrorBoundary>
{applicationRef?.app && ( const handlePointerUp = (e: FederatedMouseEvent) => {
<pixiGraphics setIsDragging(false);
draw={(g) => { // Сбрасываем флаг взаимодействия через небольшую задержку
const canvas = applicationRef.app.canvas; // чтобы избежать немедленного срабатывания useEffect
g.clear(); setTimeout(() => {
g.rect(0, 0, canvas?.width ?? 0, canvas?.height ?? 0); setIsUserInteracting(false);
g.fill("#111"); }, 100);
}} e.stopPropagation();
eventMode={'static'} };
interactive
onPointerDown={handlePointerDown} const handleWheel = (e: FederatedWheelEvent) => {
onGlobalPointerMove={handlePointerMove} e.stopPropagation();
onPointerUp={handlePointerUp} setIsUserInteracting(true); // Устанавливаем флаг при зуме
onPointerUpOutside={handlePointerUp}
onWheel={handleWheel} // Get mouse position relative to canvas
/> const mouseX = e.globalX - position.x;
)} const mouseY = e.globalY - position.y;
<pixiContainer
x={position.x} // Calculate new scale
y={position.y} const scaleMin = (routeData?.scale_min ?? 10) / SCALE_FACTOR;
scale={scale} const scaleMax = (routeData?.scale_max ?? 20) / SCALE_FACTOR;
rotation={rotation}
> const zoomFactor = e.deltaY > 0 ? 0.9 : 1.1; // Zoom out/in
{children} const newScale = Math.max(scaleMin, Math.min(scaleMax, scale * zoomFactor));
</pixiContainer> const actualZoomFactor = newScale / scale;
{/* Show center of the screen.
<pixiGraphics if (scale === newScale) {
eventMode="none" // Сбрасываем флаг, если зум не изменился
setTimeout(() => {
draw={(g) => { setIsUserInteracting(false);
g.clear(); }, 100);
const center = screenCenter ?? {x: 0, y: 0}; return;
g.circle(center.x, center.y, 1); }
g.fill("#fff");
}} // Update position to zoom towards mouse cursor
/> */} setPosition({
</ErrorBoundary> x: position.x + mouseX * (1 - actualZoomFactor),
); y: position.y + mouseY * (1 - actualZoomFactor),
});
setScale(newScale);
// Сбрасываем флаг взаимодействия через задержку
setTimeout(() => {
setIsUserInteracting(false);
}, 100);
};
useEffect(() => {
applicationRef?.app.render();
console.log(position, scale, rotation);
}, [position, scale, rotation]);
return (
<ErrorBoundary>
{applicationRef?.app && (
<pixiGraphics
draw={(g) => {
const canvas = applicationRef.app.canvas;
g.clear();
g.rect(0, 0, canvas?.width ?? 0, canvas?.height ?? 0);
g.fill("#111");
}}
eventMode={"static"}
interactive
onPointerDown={handlePointerDown}
onGlobalPointerMove={handlePointerMove}
onPointerUp={handlePointerUp}
onPointerUpOutside={handlePointerUp}
onWheel={handleWheel}
/>
)}
<pixiContainer
x={position.x}
y={position.y}
scale={scale}
rotation={rotation}
>
{children}
</pixiContainer>
{/* Show center of the screen.
<pixiGraphics
eventMode="none"
draw={(g) => {
g.clear();
const center = screenCenter ?? {x: 0, y: 0};
g.circle(center.x, center.y, 1);
g.fill("#fff");
}}
/> */}
</ErrorBoundary>
);
} }

102
src/pages/route-preview/LeftSidebar.tsx
View File

@ -1,33 +1,89 @@
import { Stack, Typography, Button } from "@mui/material"; import { Stack, Typography, Button } from "@mui/material";
import { useNavigate, useNavigationType } from "react-router";
export function LeftSidebar() { export function LeftSidebar() {
return ( const navigate = useNavigate();
<Stack direction="column" width="300px" p={2} bgcolor="primary.main"> const navigationType = useNavigationType(); // PUSH, POP, REPLACE
<Stack direction="column" alignItems="center" justifyContent="center" my={10}>
<img src={"/Emblem.svg"} alt="logo" width={100} height={100} />
<Typography sx={{ mb: 2 }} textAlign="center">
При поддержке Правительства
Санкт-Петербурга
</Typography>
</Stack>
const handleBack = () => {
if (navigationType === "PUSH") {
navigate(-1);
} else {
navigate("/route");
}
};
<Stack direction="column" alignItems="center" justifyContent="center" my={10} spacing={2}> return (
<Button variant="outlined" color="warning" fullWidth> <Stack direction="column" width="300px" p={2} bgcolor="primary.main">
Достопримечательности <button
</Button> onClick={handleBack}
<Button variant="outlined" color="warning" fullWidth> type="button"
Остановки style={{
</Button> display: "flex",
</Stack> justifyContent: "center",
alignItems: "center",
gap: 10,
color: "#fff",
backgroundColor: "#222",
borderRadius: 10,
width: "100%",
border: "none",
cursor: "pointer",
}}
>
<p>Назад</p>
</button>
<Stack direction="column" alignItems="center" justifyContent="center" my={10}> <Stack
<img src={"/GET.png"} alt="logo" width="80%" style={{margin: "0 auto"}}/> direction="column"
</Stack> alignItems="center"
justifyContent="center"
my={10}
>
<img src={"/Emblem.svg"} alt="logo" width={100} height={100} />
<Typography sx={{ mb: 2, color: "#fff" }} textAlign="center">
При поддержке Правительства Санкт-Петербурга
</Typography>
</Stack>
<Typography variant="h6" textAlign="center" mt="auto">#ВсемПоПути</Typography> <Stack
direction="column"
alignItems="center"
justifyContent="center"
my={10}
spacing={2}
>
<Button variant="outlined" color="warning" fullWidth>
Достопримечательности
</Button>
<Button variant="outlined" color="warning" fullWidth>
Остановки
</Button>
</Stack>
<Stack
direction="column"
alignItems="center"
justifyContent="center"
my={10}
>
<img
src={"/GET.png"}
alt="logo"
width="80%"
style={{ margin: "0 auto" }}
/>
</Stack>
</Stack> <Typography
); variant="h6"
textAlign="center"
mt="auto"
sx={{ color: "#fff" }}
>
#ВсемПоПути
</Typography>
</Stack>
);
} }

422
src/pages/route-preview/MapDataContext.tsx
View File

@ -1,4 +1,4 @@
import { useCustom, useApiUrl } from "@refinedev/core"; import { useApiUrl } from "@refinedev/core";
import { useParams } from "react-router"; import { useParams } from "react-router";
import { import {
createContext, createContext,
@ -16,13 +16,16 @@ import {
StationPatchData, StationPatchData,
} from "./types"; } from "./types";
import { axiosInstance } from "../../providers/data"; import { axiosInstance } from "../../providers/data";
import { languageStore, META_LANGUAGE } from "@/store/LanguageStore";
import { observer } from "mobx-react-lite";
import { axiosInstanceForGet } from "@/providers/data";
const MapDataContext = createContext<{ const MapDataContext = createContext<{
originalRouteData?: RouteData; originalRouteData?: RouteData;
originalStationData?: StationData[]; originalStationData?: StationData[];
originalSightData?: SightData[]; originalSightData?: SightData[];
routeData?: RouteData; routeData?: RouteData;
stationData?: StationData[]; stationData?: StationDataWithLanguage;
sightData?: SightData[]; sightData?: SightData[];
isRouteLoading: boolean; isRouteLoading: boolean;
@ -57,210 +60,247 @@ const MapDataContext = createContext<{
saveChanges: () => {}, saveChanges: () => {},
}); });
export function MapDataProvider({ type StationDataWithLanguage = {
children, [key: string]: StationData[];
}: Readonly<{ children: ReactNode }>) { };
const { id: routeId } = useParams<{ id: string }>(); export const MapDataProvider = observer(
const apiUrl = useApiUrl(); ({ children }: Readonly<{ children: ReactNode }>) => {
const { id: routeId } = useParams<{ id: string }>();
const apiUrl = useApiUrl();
const [originalRouteData, setOriginalRouteData] = useState<RouteData>(); const [originalRouteData, setOriginalRouteData] = useState<RouteData>();
const [originalStationData, setOriginalStationData] = const [originalStationData, setOriginalStationData] =
useState<StationData[]>(); useState<StationData[]>();
const [originalSightData, setOriginalSightData] = useState<SightData[]>(); const [originalSightData, setOriginalSightData] = useState<SightData[]>();
const [routeData, setRouteData] = useState<RouteData>(); const [routeData, setRouteData] = useState<RouteData>();
const [stationData, setStationData] = useState<StationData[]>(); const [stationData, setStationData] = useState<StationDataWithLanguage>({
const [sightData, setSightData] = useState<SightData[]>(); RU: [],
EN: [],
const [routeChanges, setRouteChanges] = useState<RouteData>({} as RouteData); ZH: [],
const [stationChanges, setStationChanges] = useState<StationPatchData[]>([]);
const [sightChanges, setSightChanges] = useState<SightPatchData[]>([]);
const { data: routeQuery, isLoading: isRouteLoading } = useCustom({
url: `${apiUrl}/route/${routeId}`,
method: "get",
});
const { data: stationQuery, isLoading: isStationLoading } = useCustom({
url: `${apiUrl}/route/${routeId}/station`,
method: "get",
});
const { data: sightQuery, isLoading: isSightLoading } = useCustom({
url: `${apiUrl}/route/${routeId}/sight`,
method: "get",
});
useEffect(() => {
// if not undefined, set original data
if (routeQuery?.data) setOriginalRouteData(routeQuery.data as RouteData);
if (stationQuery?.data)
setOriginalStationData(stationQuery.data as StationData[]);
if (sightQuery?.data) setOriginalSightData(sightQuery.data as SightData[]);
console.log("queries", routeQuery, stationQuery, sightQuery);
}, [routeQuery, stationQuery, sightQuery]);
useEffect(() => {
// combine changes with original data
if (originalRouteData)
setRouteData({ ...originalRouteData, ...routeChanges });
if (originalStationData) setStationData(originalStationData);
if (originalSightData) setSightData(originalSightData);
}, [
originalRouteData,
originalStationData,
originalSightData,
routeChanges,
stationChanges,
sightChanges,
]);
function setScaleRange(min: number, max: number) {
setRouteChanges((prev) => {
return { ...prev, scale_min: min, scale_max: max };
}); });
} const [sightData, setSightData] = useState<SightData[]>();
function setMapRotation(rotation: number) { const [routeChanges, setRouteChanges] = useState<Partial<RouteData>>({});
setRouteChanges((prev) => { const [stationChanges, setStationChanges] = useState<StationPatchData[]>(
return { ...prev, rotate: rotation }; []
}); );
} const [sightChanges, setSightChanges] = useState<SightPatchData[]>([]);
const { language } = languageStore;
function setMapCenter(x: number, y: number) { const [isRouteLoading, setIsRouteLoading] = useState(true);
setRouteChanges((prev) => { const [isStationLoading, setIsStationLoading] = useState(true);
return { ...prev, center_latitude: x, center_longitude: y }; const [isSightLoading, setIsSightLoading] = useState(true);
});
}
async function saveChanges() { useEffect(() => {
await axiosInstance.patch(`/route/${routeId}`, routeData); const fetchData = async () => {
await saveStationChanges(); try {
await saveSightChanges(); setIsRouteLoading(true);
} setIsStationLoading(true);
setIsSightLoading(true);
async function saveStationChanges() { const [
for (const station of stationChanges) { routeResponse,
const response = await axiosInstance.patch( ruStationResponse,
`/route/${routeId}/station`, enStationResponse,
station zhStationResponse,
); sightResponse,
} ] = await Promise.all([
} axiosInstanceForGet(language).get(`/route/${routeId}`),
axiosInstanceForGet("ru").get(`/route/${routeId}/station`),
axiosInstanceForGet("en").get(`/route/${routeId}/station`),
axiosInstanceForGet("zh").get(`/route/${routeId}/station`),
axiosInstanceForGet(language).get(`/route/${routeId}/sight`),
]);
async function saveSightChanges() { setOriginalRouteData(routeResponse.data as RouteData);
console.log("sightChanges", sightChanges); setOriginalStationData(ruStationResponse.data as StationData[]);
for (const sight of sightChanges) { setStationData({
const response = await axiosInstance.patch( ru: ruStationResponse.data as StationData[],
`/route/${routeId}/sight`, en: enStationResponse.data as StationData[],
sight zh: zhStationResponse.data as StationData[],
); });
} setOriginalSightData(sightResponse.data as SightData[]);
}
function setStationOffset(stationId: number, x: number, y: number) { setIsRouteLoading(false);
setStationChanges((prev) => { setIsStationLoading(false);
let found = prev.find((station) => station.station_id === stationId); setIsSightLoading(false);
if (found) { } catch (error) {
found.offset_x = x; console.error("Error fetching data:", error);
found.offset_y = y; setIsRouteLoading(false);
setIsStationLoading(false);
return prev.map((station) => { setIsSightLoading(false);
if (station.station_id === stationId) {
return found;
}
return station;
});
} else {
const foundStation = stationData?.find(
(station) => station.id === stationId
);
if (foundStation) {
return [
...prev,
{
station_id: stationId,
offset_x: x,
offset_y: y,
transfers: foundStation.transfers,
},
];
} }
return prev; };
}
});
}
function setSightCoordinates( fetchData();
sightId: number, }, [routeId]);
latitude: number,
longitude: number
) {
setSightChanges((prev) => {
let found = prev.find((sight) => sight.sight_id === sightId);
if (found) {
found.latitude = latitude;
found.longitude = longitude;
return prev.map((sight) => { useEffect(() => {
if (sight.sight_id === sightId) { // combine changes with original data
return found; if (originalRouteData)
} setRouteData({ ...originalRouteData, ...routeChanges });
return sight; if (originalSightData) setSightData(originalSightData);
}); }, [
} else {
const foundSight = sightData?.find((sight) => sight.id === sightId);
if (foundSight) {
return [
...prev,
{
sight_id: sightId,
latitude,
longitude,
},
];
}
return prev;
}
});
}
useEffect(() => {
console.log("sightChanges", sightChanges);
}, [sightChanges]);
const value = useMemo(
() => ({
originalRouteData: originalRouteData,
originalStationData: originalStationData,
originalSightData: originalSightData,
routeData: routeData,
stationData: stationData,
sightData: sightData,
isRouteLoading,
isStationLoading,
isSightLoading,
setScaleRange,
setMapRotation,
setMapCenter,
saveChanges,
setStationOffset,
setSightCoordinates,
}),
[
originalRouteData, originalRouteData,
originalStationData,
originalSightData, originalSightData,
routeData, routeChanges,
stationData, stationChanges,
sightData, sightChanges,
isRouteLoading, ]);
isStationLoading,
isSightLoading,
]
);
return ( function setScaleRange(min: number, max: number) {
<MapDataContext.Provider value={value}>{children}</MapDataContext.Provider> setRouteChanges((prev) => {
); return { ...prev, scale_min: min, scale_max: max };
} });
}
function setMapRotation(rotation: number) {
setRouteChanges((prev) => {
return { ...prev, rotate: rotation };
});
}
function setMapCenter(x: number, y: number) {
setRouteChanges((prev) => {
return { ...prev, center_latitude: x, center_longitude: y };
});
}
async function saveChanges() {
await axiosInstance.patch(`/route/${routeId}`, routeData);
await saveStationChanges();
await saveSightChanges();
}
async function saveStationChanges() {
for (const station of stationChanges) {
const response = await axiosInstance.patch(
`/route/${routeId}/station`,
station
);
}
}
async function saveSightChanges() {
console.log("sightChanges", sightChanges);
for (const sight of sightChanges) {
const response = await axiosInstance.patch(
`/route/${routeId}/sight`,
sight
);
}
}
function setStationOffset(stationId: number, x: number, y: number) {
setStationChanges((prev) => {
let found = prev.find((station) => station.station_id === stationId);
if (found) {
found.offset_x = x;
found.offset_y = y;
return prev.map((station) => {
if (station.station_id === stationId) {
return found;
}
return station;
});
} else {
const foundStation = stationData.ru?.find(
(station) => station.id === stationId
);
if (foundStation) {
return [
...prev,
{
station_id: stationId,
offset_x: x,
offset_y: y,
transfers: foundStation.transfers,
},
];
}
return prev;
}
});
}
function setSightCoordinates(
sightId: number,
latitude: number,
longitude: number
) {
setSightChanges((prev) => {
let found = prev.find((sight) => sight.sight_id === sightId);
if (found) {
found.latitude = latitude;
found.longitude = longitude;
return prev.map((sight) => {
if (sight.sight_id === sightId) {
return found;
}
return sight;
});
} else {
const foundSight = sightData?.find((sight) => sight.id === sightId);
if (foundSight) {
return [
...prev,
{
sight_id: sightId,
latitude,
longitude,
},
];
}
return prev;
}
});
}
useEffect(() => {
console.log("sightChanges", sightChanges);
}, [sightChanges]);
const value = useMemo(
() => ({
originalRouteData,
originalStationData,
originalSightData,
routeData,
stationData,
sightData,
isRouteLoading,
isStationLoading,
isSightLoading,
setScaleRange,
setMapRotation,
setMapCenter,
saveChanges,
setStationOffset,
setSightCoordinates,
}),
[
originalRouteData,
originalStationData,
originalSightData,
routeData,
stationData,
sightData,
isRouteLoading,
isStationLoading,
isSightLoading,
]
);
return (
<MapDataContext.Provider value={value}>
{children}
</MapDataContext.Provider>
);
}
);
export const useMapData = () => { export const useMapData = () => {
const context = useContext(MapDataContext); const context = useContext(MapDataContext);

381
src/pages/route-preview/RightSidebar.tsx
View File

@ -5,187 +5,228 @@ import { useTransform } from "./TransformContext";
import { coordinatesToLocal, localToCoordinates } from "./utils"; import { coordinatesToLocal, localToCoordinates } from "./utils";
export function RightSidebar() { export function RightSidebar() {
const { routeData, setScaleRange, saveChanges, originalRouteData, setMapRotation, setMapCenter } = useMapData(); const {
const { rotation, position, screenToLocal, screenCenter, rotateToAngle, setTransform } = useTransform(); routeData,
const [minScale, setMinScale] = useState<number>(1); setScaleRange,
const [maxScale, setMaxScale] = useState<number>(10); saveChanges,
const [localCenter, setLocalCenter] = useState<{x: number, y: number}>({x: 0, y: 0}); originalRouteData,
const [rotationDegrees, setRotationDegrees] = useState<number>(0); setMapRotation,
setMapCenter,
} = useMapData();
const {
rotation,
position,
screenToLocal,
screenCenter,
rotateToAngle,
setTransform,
} = useTransform();
const [minScale, setMinScale] = useState<number>(1);
const [maxScale, setMaxScale] = useState<number>(10);
const [localCenter, setLocalCenter] = useState<{ x: number; y: number }>({
x: 0,
y: 0,
});
const [rotationDegrees, setRotationDegrees] = useState<number>(0);
useEffect(() => { useEffect(() => {
if(originalRouteData) { if (originalRouteData) {
setMinScale(originalRouteData.scale_min ?? 1); setMinScale(originalRouteData.scale_min ?? 1);
setMaxScale(originalRouteData.scale_max ?? 10); setMaxScale(originalRouteData.scale_max ?? 10);
setRotationDegrees(originalRouteData.rotate ?? 0); setRotationDegrees(originalRouteData.rotate ?? 0);
setLocalCenter({x: originalRouteData.center_latitude ?? 0, y: originalRouteData.center_longitude ?? 0}); setLocalCenter({
} x: originalRouteData.center_latitude ?? 0,
}, [originalRouteData]); y: originalRouteData.center_longitude ?? 0,
});
}
}, [originalRouteData]);
useEffect(() => { useEffect(() => {
if(minScale && maxScale) { if (minScale && maxScale) {
setScaleRange(minScale, maxScale); setScaleRange(minScale, maxScale);
} }
}, [minScale, maxScale]); }, [minScale, maxScale]);
useEffect(() => {
setRotationDegrees(
((Math.round((rotation * 180) / Math.PI) % 360) + 360) % 360
);
}, [rotation]);
useEffect(() => {
setMapRotation(rotationDegrees);
}, [rotationDegrees]);
useEffect(() => { useEffect(() => {
setRotationDegrees((Math.round(rotation * 180 / Math.PI) % 360 + 360) % 360); const center = screenCenter ?? { x: 0, y: 0 };
}, [rotation]); const localCenter = screenToLocal(center.x, center.y);
useEffect(() => { const coordinates = localToCoordinates(localCenter.x, localCenter.y);
setMapRotation(rotationDegrees); setLocalCenter({ x: coordinates.latitude, y: coordinates.longitude });
}, [rotationDegrees]); }, [position]);
useEffect(() => { useEffect(() => {
const center = screenCenter ?? {x: 0, y: 0}; setMapCenter(localCenter.x, localCenter.y);
const localCenter = screenToLocal(center.x, center.y); }, [localCenter]);
const coordinates = localToCoordinates(localCenter.x, localCenter.y);
setLocalCenter({x: coordinates.latitude, y: coordinates.longitude});
}, [position]);
function setRotationFromDegrees(degrees: number) {
rotateToAngle((degrees * Math.PI) / 180);
}
useEffect(() => { function pan({ x, y }: { x: number; y: number }) {
setMapCenter(localCenter.x, localCenter.y); const coordinates = coordinatesToLocal(x, y);
}, [localCenter]); setTransform(coordinates.x, coordinates.y);
}
function setRotationFromDegrees(degrees: number) { if (!routeData) {
rotateToAngle(degrees * Math.PI / 180); console.error("routeData is null");
} return null;
}
function pan({x, y}: {x: number, y: number}) { return (
const coordinates = coordinatesToLocal(x,y); <Stack
setTransform(coordinates.x, coordinates.y); position="absolute"
} right={8}
top={8}
bottom={8}
p={2}
gap={1}
minWidth="400px"
bgcolor="primary.main"
border="1px solid #e0e0e0"
borderRadius={2}
>
<Typography variant="h6" sx={{ mb: 2, color: "#fff" }} textAlign="center">
Детали о достопримечательностях
</Typography>
if(!routeData) { <Stack spacing={2} direction="row" alignItems="center">
console.error("routeData is null"); <TextField
return null; type="number"
} label="Минимальный масштаб"
variant="filled"
value={minScale}
onChange={(e) => setMinScale(Number(e.target.value))}
style={{ backgroundColor: "#222", borderRadius: 4 }}
sx={{
"& .MuiInputLabel-root": {
color: "#fff",
},
"& .MuiInputBase-input": {
color: "#fff",
},
}}
slotProps={{
input: {
min: 0.1,
},
}}
/>
<TextField
type="number"
label="Максимальный масштаб"
variant="filled"
value={maxScale}
onChange={(e) => setMaxScale(Number(e.target.value))}
style={{ backgroundColor: "#222", borderRadius: 4, color: "#fff" }}
sx={{
"& .MuiInputLabel-root": {
color: "#fff",
},
"& .MuiInputBase-input": {
color: "#fff",
},
}}
slotProps={{
input: {
min: 0.1,
},
}}
/>
</Stack>
return ( <TextField
<Stack type="number"
position="absolute" right={8} top={8} bottom={8} p={2} label="Поворот (в градусах)"
gap={1} variant="filled"
minWidth="400px" bgcolor="primary.main" value={rotationDegrees}
border="1px solid #e0e0e0" borderRadius={2} onChange={(e) => {
> const value = Number(e.target.value);
<Typography variant="h6" sx={{ mb: 2 }} textAlign="center"> if (!isNaN(value)) {
Детали о достопримечательностях setRotationFromDegrees(value);
</Typography> }
}}
onKeyDown={(e) => {
if (e.key === "Enter") {
e.currentTarget.blur();
}
}}
style={{ backgroundColor: "#222", borderRadius: 4 }}
sx={{
"& .MuiInputLabel-root": {
color: "#fff",
},
"& .MuiInputBase-input": {
color: "#fff",
},
}}
slotProps={{
input: {
min: 0,
max: 360,
},
}}
/>
<Stack spacing={2} direction="row" alignItems="center"> <Stack direction="row" spacing={2}>
<TextField <TextField
type="number" type="number"
label="Минимальный масштаб" label="Центр карты, широта"
variant="filled" variant="filled"
value={minScale} value={Math.round(localCenter.x * 100000) / 100000}
onChange={(e) => setMinScale(Number(e.target.value))} onChange={(e) => {
style={{backgroundColor: "#222", borderRadius: 4}} setLocalCenter((prev) => ({ ...prev, x: Number(e.target.value) }));
sx={{ pan({ x: Number(e.target.value), y: localCenter.y });
'& .MuiInputLabel-root.Mui-focused': { }}
color: "#fff" style={{ backgroundColor: "#222", borderRadius: 4 }}
} sx={{
}} "& .MuiInputLabel-root": {
slotProps={{ color: "#fff",
input: { },
min: 0.1 "& .MuiInputBase-input": {
} color: "#fff",
}} },
/> }}
<TextField />
type="number" <TextField
label="Максимальный масштаб" type="number"
variant="filled" label="Центр карты, высота"
value={maxScale} variant="filled"
onChange={(e) => setMaxScale(Number(e.target.value))} value={Math.round(localCenter.y * 100000) / 100000}
style={{backgroundColor: "#222", borderRadius: 4}} onChange={(e) => {
sx={{ setLocalCenter((prev) => ({ ...prev, y: Number(e.target.value) }));
'& .MuiInputLabel-root.Mui-focused': { pan({ x: localCenter.x, y: Number(e.target.value) });
color: "#fff" }}
} style={{ backgroundColor: "#222", borderRadius: 4 }}
}} sx={{
slotProps={{ "& .MuiInputLabel-root": {
input: { color: "#fff",
min: 0.1 },
} "& .MuiInputBase-input": {
}} color: "#fff",
/> },
</Stack> }}
/>
</Stack>
<TextField <Button
type="number" variant="contained"
label="Поворот (в градусах)" color="secondary"
variant="filled" sx={{ mt: 2 }}
value={rotationDegrees} onClick={() => {
onChange={(e) => { saveChanges();
const value = Number(e.target.value); }}
if (!isNaN(value)) { >
setRotationFromDegrees(value); Сохранить изменения
} </Button>
}} </Stack>
onKeyDown={(e) => { );
if (e.key === 'Enter') {
e.currentTarget.blur();
}
}}
style={{backgroundColor: "#222", borderRadius: 4}}
sx={{
'& .MuiInputLabel-root.Mui-focused': {
color: "#fff"
}
}}
slotProps={{
input: {
min: 0,
max: 360
}
}}
/>
<Stack direction="row" spacing={2}>
<TextField
type="number"
label="Центр карты, широта"
variant="filled"
value={Math.round(localCenter.x*100000)/100000}
onChange={(e) => {
setLocalCenter(prev => ({...prev, x: Number(e.target.value)}))
pan({x: Number(e.target.value), y: localCenter.y});
}}
style={{backgroundColor: "#222", borderRadius: 4}}
sx={{
'& .MuiInputLabel-root.Mui-focused': {
color: "#fff"
}
}}
/>
<TextField
type="number"
label="Центр карты, высота"
variant="filled"
value={Math.round(localCenter.y*100000)/100000}
onChange={(e) => {
setLocalCenter(prev => ({...prev, y: Number(e.target.value)}))
pan({x: localCenter.x, y: Number(e.target.value)});
}}
style={{backgroundColor: "#222", borderRadius: 4}}
sx={{
'& .MuiInputLabel-root.Mui-focused': {
color: "#fff"
}
}}
/>
</Stack>
<Button
variant="contained"
color="secondary"
sx={{ mt: 2 }}
onClick={() => {
saveChanges();
}}
>
Сохранить изменения
</Button>
</Stack>
);
} }

207
src/pages/route-preview/Station.tsx
View File

@ -1,109 +1,148 @@
import { FederatedMouseEvent, Graphics } from "pixi.js"; import { FederatedMouseEvent, Graphics } from "pixi.js";
import { BACKGROUND_COLOR, PATH_COLOR, STATION_RADIUS, STATION_OUTLINE_WIDTH, UP_SCALE } from "./Constants"; import {
BACKGROUND_COLOR,
PATH_COLOR,
STATION_RADIUS,
STATION_OUTLINE_WIDTH,
UP_SCALE,
} from "./Constants";
import { useTransform } from "./TransformContext"; import { useTransform } from "./TransformContext";
import { useCallback, useEffect, useRef, useState } from "react"; import { useCallback, useEffect, useRef, useState } from "react";
import { StationData } from "./types"; import { StationData } from "./types";
import { useMapData } from "./MapDataContext"; import { useMapData } from "./MapDataContext";
import { coordinatesToLocal } from "./utils"; import { coordinatesToLocal } from "./utils";
import { observer } from "mobx-react-lite";
import { languageStore } from "@stores";
interface StationProps { interface StationProps {
station: StationData; station: StationData;
ruLabel: string | null;
} }
export function Station({ export const Station = observer(
station ({ station, ruLabel }: Readonly<StationProps>) => {
}: Readonly<StationProps>) { const draw = useCallback((g: Graphics) => {
const draw = useCallback((g: Graphics) => { g.clear();
g.clear(); const coordinates = coordinatesToLocal(
const coordinates = coordinatesToLocal(station.latitude, station.longitude); station.latitude,
g.circle(coordinates.x * UP_SCALE, coordinates.y * UP_SCALE, STATION_RADIUS); station.longitude
g.fill({color: PATH_COLOR}); );
g.stroke({color: BACKGROUND_COLOR, width: STATION_OUTLINE_WIDTH}); g.circle(
}, []); coordinates.x * UP_SCALE,
coordinates.y * UP_SCALE,
STATION_RADIUS
);
g.fill({ color: PATH_COLOR });
g.stroke({ color: BACKGROUND_COLOR, width: STATION_OUTLINE_WIDTH });
}, []);
return ( return (
<pixiContainer> <pixiContainer>
<pixiGraphics draw={draw}/> <pixiGraphics draw={draw} />
<StationLabel station={station}/> <StationLabel station={station} ruLabel={ruLabel} />
</pixiContainer> </pixiContainer>
); );
} }
);
export function StationLabel({ export const StationLabel = observer(
station ({ station, ruLabel }: Readonly<StationProps>) => {
}: Readonly<StationProps>) { const { language } = languageStore;
const { rotation, scale } = useTransform(); const { rotation, scale } = useTransform();
const { setStationOffset } = useMapData(); const { setStationOffset } = useMapData();
const [position, setPosition] = useState({ x: station.offset_x, y: station.offset_y }); const [position, setPosition] = useState({
const [isDragging, setIsDragging] = useState(false); x: station.offset_x,
y: station.offset_y,
});
const [isDragging, setIsDragging] = useState(false);
const [startPosition, setStartPosition] = useState({ x: 0, y: 0 }); const [startPosition, setStartPosition] = useState({ x: 0, y: 0 });
const [startMousePosition, setStartMousePosition] = useState({ x: 0, y: 0 }); const [startMousePosition, setStartMousePosition] = useState({
x: 0,
y: 0,
});
if(!station) { if (!station) {
console.error("station is null"); console.error("station is null");
return null; return null;
} }
const handlePointerDown = (e: FederatedMouseEvent) => { const handlePointerDown = (e: FederatedMouseEvent) => {
setIsDragging(true); setIsDragging(true);
setStartPosition({ setStartPosition({
x: position.x, x: position.x,
y: position.y y: position.y,
}); });
setStartMousePosition({ setStartMousePosition({
x: e.globalX, x: e.globalX,
y: e.globalY y: e.globalY,
}); });
e.stopPropagation(); e.stopPropagation();
}; };
const handlePointerMove = (e: FederatedMouseEvent) => { const handlePointerMove = (e: FederatedMouseEvent) => {
if (!isDragging) return; if (!isDragging) return;
const dx = (e.globalX - startMousePosition.x); const dx = e.globalX - startMousePosition.x;
const dy = (e.globalY - startMousePosition.y); const dy = e.globalY - startMousePosition.y;
const newPosition = { const newPosition = {
x: startPosition.x + dx, x: startPosition.x + dx,
y: startPosition.y + dy y: startPosition.y + dy,
}; };
setPosition(newPosition); setPosition(newPosition);
setStationOffset(station.id, newPosition.x, newPosition.y); setStationOffset(station.id, newPosition.x, newPosition.y);
e.stopPropagation(); e.stopPropagation();
}; };
const handlePointerUp = (e: FederatedMouseEvent) => { const handlePointerUp = (e: FederatedMouseEvent) => {
setIsDragging(false); setIsDragging(false);
e.stopPropagation(); e.stopPropagation();
}; };
const coordinates = coordinatesToLocal(station.latitude, station.longitude); const coordinates = coordinatesToLocal(station.latitude, station.longitude);
return ( return (
<pixiContainer <pixiContainer
eventMode='static' eventMode="static"
interactive interactive
onPointerDown={handlePointerDown} onPointerDown={handlePointerDown}
onGlobalPointerMove={handlePointerMove} onGlobalPointerMove={handlePointerMove}
onPointerUp={handlePointerUp} onPointerUp={handlePointerUp}
onPointerUpOutside={handlePointerUp} onPointerUpOutside={handlePointerUp}
width={48} width={48}
height={48} height={48}
x={coordinates.x * UP_SCALE} x={coordinates.x * UP_SCALE}
y={coordinates.y * UP_SCALE} y={coordinates.y * UP_SCALE}
rotation={-rotation} rotation={-rotation}
> >
<pixiText <pixiText
anchor={{x: 0.5, y: 0.5}} anchor={{ x: 0.5, y: 0.5 }}
text={station.name} text={station.name}
position={{ position={{
x: position.x/scale, x: position.x / scale,
y: position.y/scale y: position.y / scale,
}} }}
style={{ style={{
fontSize: 48, fontSize: 26,
fontWeight: 'bold', fontWeight: "bold",
fill: "#ffffff" fill: "#ffffff",
}} }}
/> />
</pixiContainer>
); {ruLabel && (
} <pixiText
anchor={{ x: 0.5, y: -1 }}
text={ruLabel}
position={{
x: position.x / scale,
y: position.y / scale,
}}
style={{
fontSize: 16,
fontWeight: "bold",
fill: "#CCCCCC",
}}
/>
)}
</pixiContainer>
);
}
);

286
src/pages/route-preview/TransformContext.tsx
View File

@ -1,150 +1,204 @@
import { createContext, ReactNode, useContext, useMemo, useState } from "react"; import {
createContext,
ReactNode,
useContext,
useMemo,
useState,
useCallback,
} from "react";
import { SCALE_FACTOR, UP_SCALE } from "./Constants"; import { SCALE_FACTOR, UP_SCALE } from "./Constants";
const TransformContext = createContext<{ const TransformContext = createContext<{
position: { x: number, y: number }, position: { x: number; y: number };
scale: number, scale: number;
rotation: number, rotation: number;
screenCenter?: { x: number, y: number }, screenCenter?: { x: number; y: number };
setPosition: React.Dispatch<React.SetStateAction<{ x: number, y: number }>>, setPosition: React.Dispatch<React.SetStateAction<{ x: number; y: number }>>;
setScale: React.Dispatch<React.SetStateAction<number>>, setScale: React.Dispatch<React.SetStateAction<number>>;
setRotation: React.Dispatch<React.SetStateAction<number>>, setRotation: React.Dispatch<React.SetStateAction<number>>;
screenToLocal: (x: number, y: number) => { x: number, y: number }, screenToLocal: (x: number, y: number) => { x: number; y: number };
localToScreen: (x: number, y: number) => { x: number, y: number }, localToScreen: (x: number, y: number) => { x: number; y: number };
rotateToAngle: (to: number, fromPosition?: {x: number, y: number}) => void, rotateToAngle: (to: number, fromPosition?: { x: number; y: number }) => void;
setTransform: (latitude: number, longitude: number, rotationDegrees?: number, scale?: number) => void, setTransform: (
setScreenCenter: React.Dispatch<React.SetStateAction<{ x: number, y: number } | undefined>> latitude: number,
longitude: number,
rotationDegrees?: number,
scale?: number
) => void;
setScreenCenter: React.Dispatch<
React.SetStateAction<{ x: number; y: number } | undefined>
>;
}>({ }>({
position: { x: 0, y: 0 }, position: { x: 0, y: 0 },
scale: 1, scale: 1,
rotation: 0, rotation: 0,
screenCenter: undefined, screenCenter: undefined,
setPosition: () => {}, setPosition: () => {},
setScale: () => {}, setScale: () => {},
setRotation: () => {}, setRotation: () => {},
screenToLocal: () => ({ x: 0, y: 0 }), screenToLocal: () => ({ x: 0, y: 0 }),
localToScreen: () => ({ x: 0, y: 0 }), localToScreen: () => ({ x: 0, y: 0 }),
rotateToAngle: () => {}, rotateToAngle: () => {},
setTransform: () => {}, setTransform: () => {},
setScreenCenter: () => {} setScreenCenter: () => {},
}); });
// Provider component // Provider component
export const TransformProvider = ({ children }: { children: ReactNode }) => { export const TransformProvider = ({ children }: { children: ReactNode }) => {
const [position, setPosition] = useState({ x: 0, y: 0 }); const [position, setPosition] = useState({ x: 0, y: 0 });
const [scale, setScale] = useState(1); const [scale, setScale] = useState(1);
const [rotation, setRotation] = useState(0); const [rotation, setRotation] = useState(0);
const [screenCenter, setScreenCenter] = useState<{x: number, y: number}>(); const [screenCenter, setScreenCenter] = useState<{ x: number; y: number }>();
function screenToLocal(screenX: number, screenY: number) { const screenToLocal = useCallback(
// Translate point relative to current pan position (screenX: number, screenY: number) => {
const translatedX = (screenX - position.x) / scale; // Translate point relative to current pan position
const translatedY = (screenY - position.y) / scale; const translatedX = (screenX - position.x) / scale;
const translatedY = (screenY - position.y) / scale;
// Rotate point around center // Rotate point around center
const cosRotation = Math.cos(-rotation); // Negative rotation to reverse transform const cosRotation = Math.cos(-rotation); // Negative rotation to reverse transform
const sinRotation = Math.sin(-rotation); const sinRotation = Math.sin(-rotation);
const rotatedX = translatedX * cosRotation - translatedY * sinRotation; const rotatedX = translatedX * cosRotation - translatedY * sinRotation;
const rotatedY = translatedX * sinRotation + translatedY * cosRotation; const rotatedY = translatedX * sinRotation + translatedY * cosRotation;
return { return {
x: rotatedX / UP_SCALE, x: rotatedX / UP_SCALE,
y: rotatedY / UP_SCALE y: rotatedY / UP_SCALE,
}; };
} },
[position.x, position.y, scale, rotation]
);
// Inverse of screenToLocal // Inverse of screenToLocal
function localToScreen(localX: number, localY: number) { const localToScreen = useCallback(
(localX: number, localY: number) => {
const upscaledX = localX * UP_SCALE;
const upscaledY = localY * UP_SCALE;
const upscaledX = localX * UP_SCALE; const cosRotation = Math.cos(rotation);
const upscaledY = localY * UP_SCALE; const sinRotation = Math.sin(rotation);
const rotatedX = upscaledX * cosRotation - upscaledY * sinRotation;
const rotatedY = upscaledX * sinRotation + upscaledY * cosRotation;
const cosRotation = Math.cos(rotation); const translatedX = rotatedX * scale + position.x;
const sinRotation = Math.sin(rotation); const translatedY = rotatedY * scale + position.y;
const rotatedX = upscaledX * cosRotation - upscaledY * sinRotation;
const rotatedY = upscaledX * sinRotation + upscaledY * cosRotation;
const translatedX = rotatedX*scale + position.x; return {
const translatedY = rotatedY*scale + position.y; x: translatedX,
y: translatedY,
};
},
[position.x, position.y, scale, rotation]
);
return { const rotateToAngle = useCallback(
x: translatedX, (to: number, fromPosition?: { x: number; y: number }) => {
y: translatedY const rotationDiff = to - rotation;
};
}
const center = screenCenter ?? { x: 0, y: 0 };
const cosDelta = Math.cos(rotationDiff);
const sinDelta = Math.sin(rotationDiff);
const currentFromPosition = fromPosition ?? position;
function rotateToAngle(to: number, fromPosition?: {x: number, y: number}) { const newPosition = {
setRotation(to); x:
const rotationDiff = to - rotation; center.x * (1 - cosDelta) +
currentFromPosition.x * cosDelta +
(center.y - currentFromPosition.y) * sinDelta,
y:
center.y * (1 - cosDelta) +
currentFromPosition.y * cosDelta +
(currentFromPosition.x - center.x) * sinDelta,
};
const center = screenCenter ?? {x: 0, y: 0}; // Update both rotation and position in a single batch to avoid stale closure
const cosDelta = Math.cos(rotationDiff); setRotation(to);
const sinDelta = Math.sin(rotationDiff); setPosition(newPosition);
},
[rotation, position, screenCenter]
);
fromPosition ??= position; const setTransform = useCallback(
(
latitude: number,
longitude: number,
rotationDegrees?: number,
useScale?: number
) => {
const selectedRotation =
rotationDegrees !== undefined
? (rotationDegrees * Math.PI) / 180
: rotation;
const selectedScale =
useScale !== undefined ? useScale / SCALE_FACTOR : scale;
const center = screenCenter ?? { x: 0, y: 0 };
setPosition({ console.log("center", center.x, center.y);
x: center.x * (1 - cosDelta) + fromPosition.x * cosDelta + (center.y - fromPosition.y) * sinDelta,
y: center.y * (1 - cosDelta) + fromPosition.y * cosDelta + (fromPosition.x - center.x) * sinDelta
});
}
function setTransform(latitude: number, longitude: number, rotationDegrees?: number, useScale ?: number) { const newPosition = {
const selectedRotation = rotationDegrees ? (rotationDegrees * Math.PI / 180) : rotation; x: -latitude * UP_SCALE * selectedScale,
const selectedScale = useScale ? useScale/SCALE_FACTOR : scale; y: -longitude * UP_SCALE * selectedScale,
const center = screenCenter ?? {x: 0, y: 0}; };
console.log("center", center.x, center.y);
const newPosition = {
x: -latitude * UP_SCALE * selectedScale,
y: -longitude * UP_SCALE * selectedScale
};
const cos = Math.cos(selectedRotation); const cosRot = Math.cos(selectedRotation);
const sin = Math.sin(selectedRotation); const sinRot = Math.sin(selectedRotation);
// Translate point relative to center, rotate, then translate back // Translate point relative to center, rotate, then translate back
const dx = newPosition.x; const dx = newPosition.x;
const dy = newPosition.y; const dy = newPosition.y;
newPosition.x = (dx * cos - dy * sin) + center.x; newPosition.x = dx * cosRot - dy * sinRot + center.x;
newPosition.y = (dx * sin + dy * cos) + center.y; newPosition.y = dx * sinRot + dy * cosRot + center.y;
// Batch state updates to avoid intermediate renders
setPosition(newPosition);
setRotation(selectedRotation);
setScale(selectedScale);
},
[rotation, scale, screenCenter]
);
setPosition(newPosition); const value = useMemo(
setRotation(selectedRotation); () => ({
setScale(selectedScale); position,
} scale,
rotation,
screenCenter,
setPosition,
setScale,
setRotation,
rotateToAngle,
screenToLocal,
localToScreen,
setTransform,
setScreenCenter,
}),
[
position,
scale,
rotation,
screenCenter,
rotateToAngle,
screenToLocal,
localToScreen,
setTransform,
]
);
const value = useMemo(() => ({ return (
position, <TransformContext.Provider value={value}>
scale, {children}
rotation, </TransformContext.Provider>
screenCenter, );
setPosition,
setScale,
setRotation,
rotateToAngle,
screenToLocal,
localToScreen,
setTransform,
setScreenCenter
}), [position, scale, rotation, screenCenter]);
return (
<TransformContext.Provider value={value}>
{children}
</TransformContext.Provider>
);
}; };
// Custom hook for easy access to transform values // Custom hook for easy access to transform values
export const useTransform = () => { export const useTransform = () => {
const context = useContext(TransformContext); const context = useContext(TransformContext);
if (!context) { if (!context) {
throw new Error('useTransform must be used within a TransformProvider'); throw new Error("useTransform must be used within a TransformProvider");
} }
return context; return context;
}; };

51
src/pages/route-preview/TravelPath.tsx
View File

@ -3,37 +3,32 @@ import { useCallback } from "react";
import { PATH_COLOR, PATH_WIDTH } from "./Constants"; import { PATH_COLOR, PATH_WIDTH } from "./Constants";
import { coordinatesToLocal } from "./utils"; import { coordinatesToLocal } from "./utils";
interface TravelPathProps { interface TravelPathProps {
points: {x: number, y: number}[]; points: { x: number; y: number }[];
} }
export function TravelPath({ export function TravelPath({ points }: Readonly<TravelPathProps>) {
points const draw = useCallback(
}: Readonly<TravelPathProps>) { (g: Graphics) => {
g.clear();
const coordStart = coordinatesToLocal(points[0].x, points[0].y);
g.moveTo(coordStart.x, coordStart.y);
for (let i = 1; i <= points.length - 1; i++) {
const coordinates = coordinatesToLocal(points[i].x, points[i].y);
g.lineTo(coordinates.x, coordinates.y);
}
g.stroke({
color: PATH_COLOR,
width: PATH_WIDTH,
});
},
[points]
);
const draw = useCallback((g: Graphics) => { if (points.length === 0) {
g.clear(); console.error("points is empty");
const coordStart = coordinatesToLocal(points[0].x, points[0].y); return null;
g.moveTo(coordStart.x, coordStart.y); }
for (let i = 1; i < points.length - 1; i++) {
const coordinates = coordinatesToLocal(points[i].x, points[i].y);
g.lineTo(coordinates.x, coordinates.y);
}
g.stroke({
color: PATH_COLOR,
width: PATH_WIDTH
});
}, [points]);
if(points.length === 0) { return <pixiGraphics draw={draw} />;
console.error("points is empty");
return null;
}
return (
<pixiGraphics
draw={draw}
/>
);
} }

66
src/pages/route-preview/Widgets.tsx
View File

@ -1,31 +1,43 @@
import { Stack, Typography } from "@mui/material"; import { Stack, Typography } from "@mui/material";
export function Widgets() { export function Widgets() {
return ( return (
<Stack <Stack
direction="column" spacing={2} direction="column"
position="absolute" spacing={2}
top={32} left={32} position="absolute"
sx={{ pointerEvents: 'none' }} top={32}
> left={32}
<Stack bgcolor="primary.main" sx={{ pointerEvents: "none" }}
width={361} height={96} >
p={2} m={2} <Stack
borderRadius={2} bgcolor="primary.main"
alignItems="center" width={361}
justifyContent="center" height={96}
> p={2}
<Typography variant="h6">Станция</Typography> m={2}
</Stack> borderRadius={2}
<Stack bgcolor="primary.main" alignItems="center"
width={223} height={262} justifyContent="center"
p={2} m={2} >
borderRadius={2} <Typography variant="h6" sx={{ color: "#fff" }}>
alignItems="center" Станция
justifyContent="center" </Typography>
> </Stack>
<Typography variant="h6">Погода</Typography> <Stack
</Stack> bgcolor="primary.main"
</Stack> width={223}
) height={262}
p={2}
m={2}
borderRadius={2}
alignItems="center"
justifyContent="center"
>
<Typography variant="h6" sx={{ color: "#fff" }}>
Погода
</Typography>
</Stack>
</Stack>
);
} }

264
src/pages/route-preview/index.tsx
View File

@ -1,18 +1,14 @@
import { useRef, useEffect, useState } from "react"; import { useRef, useEffect, useState } from "react";
import { Application, ApplicationRef, extend } from "@pixi/react";
import { import {
Application, Container,
ApplicationRef, Graphics,
extend Sprite,
} from '@pixi/react'; Texture,
import { TilingSprite,
Container, Text,
Graphics, } from "pixi.js";
Sprite,
Texture,
TilingSprite,
Text
} from 'pixi.js';
import { Stack } from "@mui/material"; import { Stack } from "@mui/material";
import { MapDataProvider, useMapData } from "./MapDataContext"; import { MapDataProvider, useMapData } from "./MapDataContext";
import { TransformProvider, useTransform } from "./TransformContext"; import { TransformProvider, useTransform } from "./TransformContext";
@ -25,128 +21,152 @@ import { LeftSidebar } from "./LeftSidebar";
import { RightSidebar } from "./RightSidebar"; import { RightSidebar } from "./RightSidebar";
import { Widgets } from "./Widgets"; import { Widgets } from "./Widgets";
import { coordinatesToLocal } from "./utils"; import { coordinatesToLocal } from "./utils";
import { LanguageSwitch } from "@/components/LanguageSwitch";
import { languageStore } from "@stores";
import { observer } from "mobx-react-lite";
extend({ extend({
Container, Container,
Graphics, Graphics,
Sprite, Sprite,
Texture, Texture,
TilingSprite, TilingSprite,
Text Text,
}); });
export const RoutePreview = () => { export const RoutePreview = () => {
return ( return (
<MapDataProvider> <MapDataProvider>
<TransformProvider> <TransformProvider>
<Stack direction="row" height="100vh" width="100vw" overflow="hidden"> <Stack direction="row" height="100vh" width="100vw" overflow="hidden">
<LeftSidebar /> <div
<Stack direction="row" flex={1} position="relative" height="100%"> style={{
<Widgets /> position: "absolute",
<RouteMap /> top: 0,
<RightSidebar /> left: "50%",
</Stack> transform: "translateX(-50%)",
zIndex: 1000,
</Stack> }}
</TransformProvider> >
</MapDataProvider> <LanguageSwitch />
); </div>
<LeftSidebar />
<Stack direction="row" flex={1} position="relative" height="100%">
<Widgets />
<RouteMap />
<RightSidebar />
</Stack>
</Stack>
</TransformProvider>
</MapDataProvider>
);
}; };
export const RouteMap = observer(() => {
const { language } = languageStore;
const { setPosition, screenToLocal, setTransform, screenCenter } =
useTransform();
const { routeData, stationData, sightData, originalRouteData } = useMapData();
console.log(stationData);
const [points, setPoints] = useState<{ x: number; y: number }[]>([]);
const [isSetup, setIsSetup] = useState(false);
export function RouteMap() { const parentRef = useRef<HTMLDivElement>(null);
const { setPosition, screenToLocal, setTransform, screenCenter } = useTransform();
const {
routeData, stationData, sightData, originalRouteData
} = useMapData();
const [points, setPoints] = useState<{x: number, y: number}[]>([]);
const [isSetup, setIsSetup] = useState(false);
const parentRef = useRef<HTMLDivElement>(null); useEffect(() => {
if (originalRouteData) {
const path = originalRouteData?.path;
const points =
path?.map(([x, y]: [number, number]) => ({
x: x * UP_SCALE,
y: y * UP_SCALE,
})) ?? [];
setPoints(points);
}
}, [originalRouteData]);
useEffect(() => { useEffect(() => {
if (originalRouteData) { if (isSetup || !screenCenter) {
const path = originalRouteData?.path; return;
const points = path?.map(([x, y]: [number, number]) => ({x: x * UP_SCALE, y: y * UP_SCALE})) ?? []; }
setPoints(points);
}
}, [originalRouteData]);
useEffect(() => { if (
if(isSetup || !screenCenter) { originalRouteData?.center_latitude ===
return; originalRouteData?.center_longitude &&
} originalRouteData?.center_latitude === 0
) {
if (points.length > 0) {
let boundingBox = {
from: { x: Infinity, y: Infinity },
to: { x: -Infinity, y: -Infinity },
};
for (const point of points) {
boundingBox.from.x = Math.min(boundingBox.from.x, point.x);
boundingBox.from.y = Math.min(boundingBox.from.y, point.y);
boundingBox.to.x = Math.max(boundingBox.to.x, point.x);
boundingBox.to.y = Math.max(boundingBox.to.y, point.y);
}
const newCenter = {
x: -(boundingBox.from.x + boundingBox.to.x) / 2,
y: -(boundingBox.from.y + boundingBox.to.y) / 2,
};
setPosition(newCenter);
setIsSetup(true);
}
} else if (
originalRouteData?.center_latitude &&
originalRouteData?.center_longitude
) {
const coordinates = coordinatesToLocal(
originalRouteData?.center_latitude,
originalRouteData?.center_longitude
);
if ( setTransform(
originalRouteData?.center_latitude === originalRouteData?.center_longitude && coordinates.x,
originalRouteData?.center_latitude === 0 coordinates.y,
) { originalRouteData?.rotate,
if (points.length > 0) { originalRouteData?.scale_min
let boundingBox = { );
from: {x: Infinity, y: Infinity}, setIsSetup(true);
to: {x: -Infinity, y: -Infinity} }
}; }, [
for (const point of points) { points,
boundingBox.from.x = Math.min(boundingBox.from.x, point.x); originalRouteData?.center_latitude,
boundingBox.from.y = Math.min(boundingBox.from.y, point.y); originalRouteData?.center_longitude,
boundingBox.to.x = Math.max(boundingBox.to.x, point.x); originalRouteData?.rotate,
boundingBox.to.y = Math.max(boundingBox.to.y, point.y); isSetup,
} screenCenter,
const newCenter = { ]);
x: -(boundingBox.from.x + boundingBox.to.x) / 2,
y: -(boundingBox.from.y + boundingBox.to.y) / 2
};
setPosition(newCenter);
setIsSetup(true);
}
} else if (
originalRouteData?.center_latitude &&
originalRouteData?.center_longitude
) {
const coordinates = coordinatesToLocal(originalRouteData?.center_latitude, originalRouteData?.center_longitude);
setTransform( if (!routeData || !stationData || !sightData) {
coordinates.x, console.error("routeData, stationData or sightData is null");
coordinates.y, return <div>Loading...</div>;
originalRouteData?.rotate, }
originalRouteData?.scale_min
);
setIsSetup(true);
}
}, [points, originalRouteData?.center_latitude, originalRouteData?.center_longitude, originalRouteData?.rotate, isSetup, screenCenter]);
return (
<div style={{ width: "100%", height: "100%" }} ref={parentRef}>
<Application resizeTo={parentRef} background="#fff">
<InfiniteCanvas>
<TravelPath points={points} />
{stationData[language].map((obj, index) => (
<Station
station={obj}
key={obj.id}
ruLabel={language === "ru" ? null : stationData.ru[index].name}
/>
))}
if (!routeData || !stationData || !sightData) { <pixiGraphics
console.error("routeData, stationData or sightData is null"); draw={(g) => {
return <div>Loading...</div>; g.clear();
} const localCenter = screenToLocal(0, 0);
g.circle(localCenter.x, localCenter.y, 10);
g.fill("#fff");
return ( }}
<div style={{width: "100%", height:"100%"}} ref={parentRef}> />
<Application </InfiniteCanvas>
resizeTo={parentRef} </Application>
background="#fff" </div>
> );
<InfiniteCanvas> });
<TravelPath points={points}/>
{stationData?.map((obj) => (
<Station station={obj} key={obj.id}/>
))}
{sightData?.map((obj, index) => (
<Sight sight={obj} id={index} key={obj.id}/>
))}
<pixiGraphics
draw={(g) => {
g.clear();
const localCenter = screenToLocal(0,0);
g.circle(localCenter.x, localCenter.y, 10);
g.fill("#fff");
}}
/>
</InfiniteCanvas>
</Application>
</div>
)
}

16
src/pages/route/create.tsx
View File

@ -280,13 +280,19 @@ export const RouteCreate = () => {
<TextField <TextField
{...register("scale_min", { {...register("scale_min", {
// required: 'Это поле является обязательным', // required: 'Это поле является обязательным',
setValueAs: (value) => Number(value), setValueAs: (value) => {
if (Number(value) < 0) {
return 0;
}
return Number(value);
},
})} })}
error={!!(errors as any)?.scale_min} error={!!(errors as any)?.scale_min}
helperText={(errors as any)?.scale_min?.message} helperText={(errors as any)?.scale_min?.message}
margin="normal" margin="normal"
fullWidth fullWidth
slotProps={{ inputLabel: { shrink: true } }} slotProps={{ inputLabel: { shrink: true } }}
inputProps={{ min: 0 }}
type="number" type="number"
label={"Масштаб (мин)"} label={"Масштаб (мин)"}
name="scale_min" name="scale_min"
@ -295,13 +301,19 @@ export const RouteCreate = () => {
<TextField <TextField
{...register("scale_max", { {...register("scale_max", {
// required: 'Это поле является обязательным', // required: 'Это поле является обязательным',
setValueAs: (value) => Number(value), setValueAs: (value) => {
if (Number(value) < 0) {
return 0;
}
return Number(value);
},
})} })}
error={!!(errors as any)?.scale_max} error={!!(errors as any)?.scale_max}
helperText={(errors as any)?.scale_max?.message} helperText={(errors as any)?.scale_max?.message}
margin="normal" margin="normal"
fullWidth fullWidth
slotProps={{ inputLabel: { shrink: true } }} slotProps={{ inputLabel: { shrink: true } }}
inputProps={{ min: 0 }}
type="number" type="number"
label={"Масштаб (макс)"} label={"Масштаб (макс)"}
name="scale_max" name="scale_max"

28
src/pages/route/edit.tsx
View File

@ -9,7 +9,7 @@ import {
} from "@mui/material"; } from "@mui/material";
import { Edit, useAutocomplete } from "@refinedev/mui"; import { Edit, useAutocomplete } from "@refinedev/mui";
import { useForm } from "@refinedev/react-hook-form"; import { useForm } from "@refinedev/react-hook-form";
import { Controller } from "react-hook-form"; import { Controller, useWatch } from "react-hook-form";
import { useNavigate, useParams } from "react-router"; import { useNavigate, useParams } from "react-router";
import { LinkedItems } from "../../components/LinkedItems"; import { LinkedItems } from "../../components/LinkedItems";
import { import {
@ -76,6 +76,11 @@ export const RouteEdit = observer(() => {
...META_LANGUAGE(language), ...META_LANGUAGE(language),
}); });
const carrierId = useWatch({ control, name: "carrier_id" });
const cityId = carrierAutocompleteProps.options.find(
(option) => option.id === carrierId
)?.city_id;
const { autocompleteProps: governorAppealAutocompleteProps } = const { autocompleteProps: governorAppealAutocompleteProps } =
useAutocomplete({ useAutocomplete({
resource: "article", resource: "article",
@ -312,7 +317,12 @@ export const RouteEdit = observer(() => {
<TextField <TextField
{...register("scale_min", { {...register("scale_min", {
// required: 'Это поле является обязательным', // required: 'Это поле является обязательным',
setValueAs: (value) => Number(value), setValueAs: (value) => {
if (Number(value) < 0) {
return 0;
}
return Number(value);
},
})} })}
error={!!(errors as any)?.scale_min} error={!!(errors as any)?.scale_min}
helperText={(errors as any)?.scale_min?.message} helperText={(errors as any)?.scale_min?.message}
@ -327,7 +337,12 @@ export const RouteEdit = observer(() => {
<TextField <TextField
{...register("scale_max", { {...register("scale_max", {
// required: 'Это поле является обязательным', // required: 'Это поле является обязательным',
setValueAs: (value) => Number(value), setValueAs: (value) => {
if (Number(value) < 0) {
return 0;
}
return Number(value);
},
})} })}
error={!!(errors as any)?.scale_max} error={!!(errors as any)?.scale_max}
helperText={(errors as any)?.scale_max?.message} helperText={(errors as any)?.scale_max?.message}
@ -393,18 +408,19 @@ export const RouteEdit = observer(() => {
parentResource="route" parentResource="route"
childResource="station" childResource="station"
fields={stationFields} fields={stationFields}
title="станции" title="остановки"
dragAllowed={true} dragAllowed={true}
cityId={cityId}
/> />
<LinkedItems<VehicleItem> {/* <LinkedItems<VehicleItem>
type="edit" type="edit"
parentId={routeId} parentId={routeId}
parentResource="route" parentResource="route"
childResource="vehicle" childResource="vehicle"
fields={vehicleFields} fields={vehicleFields}
title="транспортные средства" title="транспортные средства"
/> /> */}
</> </>
)} )}

9
src/pages/route/show.tsx
View File

@ -80,17 +80,17 @@ export const RouteShow = observer(() => {
parentResource="route" parentResource="route"
childResource="station" childResource="station"
fields={stationFields} fields={stationFields}
title="станции" title="остановки"
/> />
<LinkedItems<VehicleItem> {/* <LinkedItems<VehicleItem>
type="show" type="show"
parentId={record.id} parentId={record.id}
parentResource="route" parentResource="route"
childResource="vehicle" childResource="vehicle"
fields={vehicleFields} fields={vehicleFields}
title="транспортные средства" title="транспортные средства"
/> /> */}
<LinkedItems<SightItem> <LinkedItems<SightItem>
type="show" type="show"
@ -103,8 +103,7 @@ export const RouteShow = observer(() => {
</> </>
)} )}
<Box sx={{ display: "flex", justifyContent: "flex-start" }}>
<Box sx={{ display: 'flex', justifyContent: 'flex-start' }}>
<Button <Button
variant="contained" variant="contained"
color="primary" color="primary"

4
src/pages/sight/create.tsx
View File

@ -433,7 +433,7 @@ export const SightCreate = observer(() => {
renderInput={(params) => ( renderInput={(params) => (
<TextField <TextField
{...params} {...params}
label="Выберите водный знак (Левый верх)" label="Выберите водяной знак (Левый верх)"
margin="normal" margin="normal"
variant="outlined" variant="outlined"
error={!!errors.watermark_lu} error={!!errors.watermark_lu}
@ -475,7 +475,7 @@ export const SightCreate = observer(() => {
renderInput={(params) => ( renderInput={(params) => (
<TextField <TextField
{...params} {...params}
label="Выберите водный знак (Правый верх)" label="Выберите водяной знак (Правый верх)"
margin="normal" margin="normal"
variant="outlined" variant="outlined"
error={!!errors.watermark_rd} error={!!errors.watermark_rd}

8
src/pages/sight/edit.tsx
View File

@ -606,7 +606,7 @@ export const SightEdit = observer(() => {
renderInput={(params) => ( renderInput={(params) => (
<TextField <TextField
{...params} {...params}
label="Выберите водный знак (Левый верх)" label="Выберите водяной знак (Левый верх)"
margin="normal" margin="normal"
variant="outlined" variant="outlined"
error={!!errors.arms} error={!!errors.arms}
@ -650,7 +650,7 @@ export const SightEdit = observer(() => {
renderInput={(params) => ( renderInput={(params) => (
<TextField <TextField
{...params} {...params}
label="Выберите водный знак (Правый вверх)" label="Выберите водяной знак (Правый вверх)"
margin="normal" margin="normal"
variant="outlined" variant="outlined"
error={!!errors.arms} error={!!errors.arms}
@ -1479,7 +1479,7 @@ export const SightEdit = observer(() => {
renderInput={(params) => ( renderInput={(params) => (
<TextField <TextField
{...params} {...params}
label="Выберите водный знак (Левый верх)" label="Выберите водяной знак (Левый верх)"
margin="normal" margin="normal"
variant="outlined" variant="outlined"
error={!!errors.arms} error={!!errors.arms}
@ -1523,7 +1523,7 @@ export const SightEdit = observer(() => {
renderInput={(params) => ( renderInput={(params) => (
<TextField <TextField
{...params} {...params}
label="Выберите водный знак (Правый вверх)" label="Выберите водяной знак (Правый вверх)"
margin="normal" margin="normal"
variant="outlined" variant="outlined"
error={!!errors.arms} error={!!errors.arms}

3
src/pages/station/edit.tsx
View File

@ -192,6 +192,8 @@ export const StationEdit = observer(() => {
}, },
}); });
const cityId = watch("city_id");
return ( return (
<Edit saveButtonProps={saveButtonProps}> <Edit saveButtonProps={saveButtonProps}>
<Box <Box
@ -353,6 +355,7 @@ export const StationEdit = observer(() => {
fields={sightFields} fields={sightFields}
title="достопримечательности" title="достопримечательности"
dragAllowed={false} dragAllowed={false}
cityId={cityId}
/> />
)} )}
</Edit> </Edit>

63
src/pages/vehicle/list.tsx
View File

@ -7,14 +7,41 @@ import {
ShowButton, ShowButton,
useDataGrid, useDataGrid,
} from "@refinedev/mui"; } from "@refinedev/mui";
import React, { useEffect } from "react"; import React, { useEffect, useState } from "react";
import { VEHICLE_TYPES } from "../../lib/constants"; import { VEHICLE_TYPES } from "../../lib/constants";
import { localeText } from "../../locales/ru/localeText"; import { localeText } from "../../locales/ru/localeText";
import { observer } from "mobx-react-lite"; import { observer } from "mobx-react-lite";
import { languageStore } from "../../store/LanguageStore"; import { languageStore } from "../../store/LanguageStore";
import { axiosInstance } from "@providers";
export const VehicleList = observer(() => { export const VehicleList = observer(() => {
const [carriers, setCarriers] = useState<any[]>([]);
const [cities, setCities] = useState<any[]>([]);
useEffect(() => {
axiosInstance
.get("/carrier")
.then((res) => {
setCarriers(res.data);
})
.catch((err) => {
console.log(err);
});
}, []);
useEffect(() => {
axiosInstance
.get("/city")
.then((res) => {
setCities(res.data);
})
.catch((err) => {
console.log(err);
});
}, []);
const { language } = languageStore; const { language } = languageStore;
const { dataGridProps } = useDataGrid({ const { dataGridProps } = useDataGrid({
@ -71,6 +98,36 @@ export const VehicleList = observer(() => {
); );
}, },
}, },
{
field: "carrier-name",
headerName: "Перевозчик",
type: "string",
minWidth: 150,
display: "flex",
align: "left",
headerAlign: "left",
renderCell: (params) => {
const value = params.row.carrier_id;
return carriers.find((carrier) => carrier.id === value)?.full_name;
},
},
{
field: "city-name",
headerName: "Город",
type: "string",
minWidth: 150,
display: "flex",
align: "left",
headerAlign: "left",
renderCell: (params) => {
const value = params.row.carrier_id;
return cities.find(
(city) =>
city.id ===
carriers.find((carrier) => carrier.id === value)?.city_id
)?.name;
},
},
// { // {
// field: "city", // field: "city",
// headerName: "Город", // headerName: "Город",
@ -93,7 +150,7 @@ export const VehicleList = observer(() => {
return ( return (
<> <>
<EditButton hideText recordItemId={row.id} /> <EditButton hideText recordItemId={row.id} />
<ShowButton hideText recordItemId={row.id} /> {/* <ShowButton hideText recordItemId={row.id} /> */}
<DeleteButton <DeleteButton
hideText hideText
confirmTitle="Вы уверены?" confirmTitle="Вы уверены?"
@ -104,7 +161,7 @@ export const VehicleList = observer(() => {
}, },
}, },
], ],
[] [carriers, cities]
); );
return ( return (

18
src/providers/data.ts
View File

@ -3,7 +3,7 @@ import dataProvider from "@refinedev/simple-rest";
import { TOKEN_KEY } from "@providers"; import { TOKEN_KEY } from "@providers";
import axios from "axios"; import axios from "axios";
import { languageStore } from "@stores";
export const axiosInstance = axios.create({ export const axiosInstance = axios.create({
baseURL: import.meta.env.VITE_KRBL_API, baseURL: import.meta.env.VITE_KRBL_API,
}); });
@ -22,6 +22,22 @@ axiosInstance.interceptors.request.use((config) => {
return config; return config;
}); });
export const axiosInstanceForGet = (language: string) => {
const axiosInstance = axios.create({
baseURL: import.meta.env.VITE_KRBL_API,
});
axiosInstance.interceptors.request.use((config) => {
const token = localStorage.getItem(TOKEN_KEY);
if (token) {
config.headers.Authorization = `Bearer ${token}`;
}
config.headers["X-Language"] = language;
return config;
});
return axiosInstance;
};
const apiUrl = import.meta.env.VITE_KRBL_API; const apiUrl = import.meta.env.VITE_KRBL_API;
export const customDataProvider = dataProvider(apiUrl, axiosInstance); export const customDataProvider = dataProvider(apiUrl, axiosInstance);