create branch dev and commit code
This commit is contained in:
parent
3b70cc9fe8
commit
ea68fa5cc4
44 changed files with 12421 additions and 214 deletions
|
|
@ -7,16 +7,27 @@ async function sendToAndroid(message: any) {
|
|||
let writer: any = get(adbWriter);
|
||||
console.log('writer', writer);
|
||||
if (!writer) {
|
||||
// addNotification('ERR:No active connection');
|
||||
return;
|
||||
addNotification('ERR:No active Android connection');
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
const encoder = new TextEncoder();
|
||||
// console.log(writer);
|
||||
await writer.write(encoder.encode(JSON.stringify(message) + '\n'));
|
||||
console.log('sent! ', JSON.stringify(message).length);
|
||||
const serializedMessage = JSON.stringify(message);
|
||||
await writer.write(encoder.encode(serializedMessage + '\n'));
|
||||
console.log('[ADB] sent', {
|
||||
type: message?.type,
|
||||
bytes: serializedMessage.length,
|
||||
productCode: message?.payload?.data?.productCode,
|
||||
batchCount: Array.isArray(message?.payload?.data) ? message.payload.data.length : undefined,
|
||||
batchProductCodes: Array.isArray(message?.payload?.data)
|
||||
? message.payload.data.map((menu: any) => menu?.productCode)
|
||||
: undefined
|
||||
});
|
||||
return true;
|
||||
} catch (error) {
|
||||
console.error('write failed', error);
|
||||
addNotification('ERR:Failed to send message to Android');
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
249
src/lib/core/stores/genLayoutStore.ts
Normal file
249
src/lib/core/stores/genLayoutStore.ts
Normal file
|
|
@ -0,0 +1,249 @@
|
|||
import { writable, get } from 'svelte/store';
|
||||
|
||||
export interface GenLayoutFile {
|
||||
file: string;
|
||||
content: string;
|
||||
file_index: number;
|
||||
}
|
||||
|
||||
export interface GenLayoutBatch {
|
||||
batch_id: string;
|
||||
total_files: number;
|
||||
total_size_bytes: number;
|
||||
status: 'idle' | 'generating' | 'receiving' | 'complete' | 'error';
|
||||
files: GenLayoutFile[];
|
||||
error?: string;
|
||||
}
|
||||
|
||||
// Track chunked file parts: Map<file_index, Map<part_index, content>>
|
||||
interface ChunkedFileTracker {
|
||||
file: string;
|
||||
file_index: number;
|
||||
total_parts: number;
|
||||
parts: Map<number, string>;
|
||||
}
|
||||
|
||||
const initialState: GenLayoutBatch = {
|
||||
batch_id: '',
|
||||
total_files: 0,
|
||||
total_size_bytes: 0,
|
||||
status: 'idle',
|
||||
files: []
|
||||
};
|
||||
|
||||
export const genLayoutBatch = writable<GenLayoutBatch>(initialState);
|
||||
|
||||
// Track chunked files being assembled
|
||||
const chunkedFiles = new Map<number, ChunkedFileTracker>();
|
||||
|
||||
// Callbacks for when batch completes
|
||||
let onBatchCompleteCallback: ((files: GenLayoutFile[]) => void) | null = null;
|
||||
|
||||
export function setOnBatchCompleteCallback(cb: (files: GenLayoutFile[]) => void) {
|
||||
onBatchCompleteCallback = cb;
|
||||
}
|
||||
|
||||
export function clearOnBatchCompleteCallback() {
|
||||
onBatchCompleteCallback = null;
|
||||
}
|
||||
|
||||
export function handleGenLayoutBatchStart(payload: {
|
||||
batch_id: string;
|
||||
total_files: number;
|
||||
total_size_bytes: number;
|
||||
}) {
|
||||
genLayoutBatch.set({
|
||||
batch_id: payload.batch_id,
|
||||
total_files: payload.total_files,
|
||||
total_size_bytes: payload.total_size_bytes,
|
||||
status: 'receiving',
|
||||
files: []
|
||||
});
|
||||
console.log('[GenLayout] Batch started:', payload.batch_id, 'total files:', payload.total_files);
|
||||
}
|
||||
|
||||
export function handleGenLayoutFile(payload: {
|
||||
batch_id: string;
|
||||
file_index: number;
|
||||
total_files: number;
|
||||
file: string;
|
||||
content: string;
|
||||
is_chunked?: boolean;
|
||||
part_index?: number;
|
||||
total_parts?: number;
|
||||
is_last_part?: boolean;
|
||||
}) {
|
||||
const batch = get(genLayoutBatch);
|
||||
if (batch.batch_id !== payload.batch_id) return;
|
||||
|
||||
if (payload.is_chunked) {
|
||||
const fileIndex = payload.file_index;
|
||||
const partIndex = payload.part_index ?? 0;
|
||||
const totalParts = payload.total_parts ?? 1;
|
||||
|
||||
// Get or create tracker for this file
|
||||
let tracker = chunkedFiles.get(fileIndex);
|
||||
if (!tracker) {
|
||||
tracker = {
|
||||
file: payload.file,
|
||||
file_index: fileIndex,
|
||||
total_parts: totalParts,
|
||||
parts: new Map()
|
||||
};
|
||||
chunkedFiles.set(fileIndex, tracker);
|
||||
}
|
||||
|
||||
// Store this chunk
|
||||
tracker.parts.set(partIndex, payload.content);
|
||||
|
||||
console.log(
|
||||
'[GenLayout] Received chunk:',
|
||||
partIndex + 1,
|
||||
'/',
|
||||
totalParts,
|
||||
'for file',
|
||||
fileIndex + 1,
|
||||
'/',
|
||||
payload.total_files,
|
||||
payload.file
|
||||
);
|
||||
|
||||
// Check if all parts received
|
||||
if (tracker.parts.size === totalParts) {
|
||||
// Assemble the complete file content
|
||||
const sortedParts: string[] = [];
|
||||
for (let i = 0; i < totalParts; i++) {
|
||||
sortedParts.push(tracker.parts.get(i) ?? '');
|
||||
}
|
||||
const completeContent = sortedParts.join('');
|
||||
|
||||
// Add to files
|
||||
addFileToStore(payload.batch_id, {
|
||||
file: payload.file,
|
||||
content: completeContent,
|
||||
file_index: fileIndex
|
||||
}, payload.total_files);
|
||||
|
||||
// Clean up tracker
|
||||
chunkedFiles.delete(fileIndex);
|
||||
|
||||
console.log(
|
||||
'[GenLayout] Assembled chunked file:',
|
||||
fileIndex + 1,
|
||||
'/',
|
||||
payload.total_files,
|
||||
payload.file
|
||||
);
|
||||
}
|
||||
} else {
|
||||
// Handle non-chunked file
|
||||
addFileToStore(payload.batch_id, {
|
||||
file: payload.file,
|
||||
content: payload.content,
|
||||
file_index: payload.file_index
|
||||
}, payload.total_files);
|
||||
|
||||
console.log(
|
||||
'[GenLayout] Received file:',
|
||||
payload.file_index + 1,
|
||||
'/',
|
||||
payload.total_files,
|
||||
payload.file
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function addFileToStore(batchId: string, file: GenLayoutFile, totalFiles: number) {
|
||||
genLayoutBatch.update((batch) => {
|
||||
if (batch.batch_id !== batchId) return batch;
|
||||
|
||||
const existingIndex = batch.files.findIndex((f) => f.file_index === file.file_index);
|
||||
const newFiles =
|
||||
existingIndex >= 0
|
||||
? batch.files.map((f, index) => (index === existingIndex ? file : f))
|
||||
: [...batch.files, file];
|
||||
const sortedFiles = newFiles.sort((a, b) => a.file_index - b.file_index);
|
||||
|
||||
return {
|
||||
...batch,
|
||||
total_files: totalFiles || batch.total_files,
|
||||
files: sortedFiles
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
export function handleGenLayoutBatchEnd(payload: { batch_id: string; total_files: number }) {
|
||||
const batch = get(genLayoutBatch);
|
||||
|
||||
if (batch.batch_id !== payload.batch_id) return;
|
||||
|
||||
const expectedTotal = payload.total_files || batch.total_files;
|
||||
const sortedFiles = [...batch.files].sort((a, b) => a.file_index - b.file_index);
|
||||
const missingIndexes = getMissingFileIndexes(sortedFiles, expectedTotal);
|
||||
|
||||
if (missingIndexes.length > 0) {
|
||||
// const error = `Gen Layout incomplete: received ${sortedFiles.length}/${expectedTotal} files. Missing file index: ${missingIndexes.join(', ')}`;
|
||||
const error = `ไฟล์ไม่ครับ ทั้งหมด: ${sortedFiles.length}/${expectedTotal}`
|
||||
genLayoutBatch.update((b) => ({
|
||||
...b,
|
||||
total_files: expectedTotal,
|
||||
status: 'error',
|
||||
files: sortedFiles,
|
||||
error
|
||||
}));
|
||||
console.warn('[GenLayout] Batch incomplete:', error, sortedFiles);
|
||||
return;
|
||||
}
|
||||
|
||||
genLayoutBatch.update((b) => ({
|
||||
...b,
|
||||
total_files: expectedTotal,
|
||||
status: 'complete',
|
||||
files: sortedFiles
|
||||
}));
|
||||
|
||||
console.log('[GenLayout] Batch complete, received', sortedFiles.length, 'files');
|
||||
|
||||
if (onBatchCompleteCallback) {
|
||||
onBatchCompleteCallback(sortedFiles);
|
||||
}
|
||||
}
|
||||
|
||||
function getMissingFileIndexes(files: GenLayoutFile[], totalFiles: number) {
|
||||
if (totalFiles <= 0) return [];
|
||||
|
||||
const receivedIndexes = new Set(files.map((file) => file.file_index));
|
||||
const indexes = [...receivedIndexes];
|
||||
const startsAtOne = indexes.length > 0 && Math.min(...indexes) >= 1;
|
||||
const firstIndex = startsAtOne ? 1 : 0;
|
||||
const lastIndex = startsAtOne ? totalFiles : totalFiles - 1;
|
||||
const missingIndexes: number[] = [];
|
||||
|
||||
for (let index = firstIndex; index <= lastIndex; index += 1) {
|
||||
if (!receivedIndexes.has(index)) {
|
||||
missingIndexes.push(index);
|
||||
}
|
||||
}
|
||||
|
||||
return missingIndexes;
|
||||
}
|
||||
|
||||
export function handleGenLayoutError(error: string) {
|
||||
genLayoutBatch.update((batch) => ({
|
||||
...batch,
|
||||
status: 'error',
|
||||
error
|
||||
}));
|
||||
}
|
||||
|
||||
export function resetGenLayoutBatch() {
|
||||
genLayoutBatch.set(initialState);
|
||||
chunkedFiles.clear();
|
||||
}
|
||||
|
||||
export function setGenLayoutGenerating() {
|
||||
genLayoutBatch.update((batch) => ({
|
||||
...batch,
|
||||
status: 'generating'
|
||||
}));
|
||||
}
|
||||
85
src/lib/core/stores/menuSaveStore.ts
Normal file
85
src/lib/core/stores/menuSaveStore.ts
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
import { writable, get } from 'svelte/store';
|
||||
|
||||
export type MenuSaveStatus = 'idle' | 'saving' | 'saved' | 'error';
|
||||
|
||||
export interface MenuSaveState {
|
||||
productCode: string;
|
||||
status: MenuSaveStatus;
|
||||
error?: string;
|
||||
savedAt?: number;
|
||||
}
|
||||
|
||||
// Store for tracking menu save status
|
||||
export const menuSaveStates = writable<Map<string, MenuSaveState>>(new Map());
|
||||
|
||||
// Callback to be called when a menu is saved successfully
|
||||
let onMenuSavedCallback: ((productCode: string) => void) | null = null;
|
||||
|
||||
export function setOnMenuSavedCallback(callback: (productCode: string) => void) {
|
||||
onMenuSavedCallback = callback;
|
||||
}
|
||||
|
||||
export function clearOnMenuSavedCallback() {
|
||||
onMenuSavedCallback = null;
|
||||
}
|
||||
|
||||
export function setMenuSaving(productCode: string) {
|
||||
menuSaveStates.update((states) => {
|
||||
const newStates = new Map(states);
|
||||
newStates.set(productCode, {
|
||||
productCode,
|
||||
status: 'saving'
|
||||
});
|
||||
return newStates;
|
||||
});
|
||||
}
|
||||
|
||||
export function setMenuSaved(productCode: string) {
|
||||
menuSaveStates.update((states) => {
|
||||
const newStates = new Map(states);
|
||||
newStates.set(productCode, {
|
||||
productCode,
|
||||
status: 'saved',
|
||||
savedAt: Date.now()
|
||||
});
|
||||
return newStates;
|
||||
});
|
||||
|
||||
// Call the callback if registered
|
||||
if (onMenuSavedCallback) {
|
||||
onMenuSavedCallback(productCode);
|
||||
}
|
||||
}
|
||||
|
||||
export function setMenuSaveError(productCode: string, error: string) {
|
||||
menuSaveStates.update((states) => {
|
||||
const newStates = new Map(states);
|
||||
newStates.set(productCode, {
|
||||
productCode,
|
||||
status: 'error',
|
||||
error
|
||||
});
|
||||
return newStates;
|
||||
});
|
||||
}
|
||||
|
||||
export function clearMenuSaveState(productCode: string) {
|
||||
menuSaveStates.update((states) => {
|
||||
const newStates = new Map(states);
|
||||
newStates.delete(productCode);
|
||||
return newStates;
|
||||
});
|
||||
}
|
||||
|
||||
export function getMenuSaveStatus(productCode: string): MenuSaveStatus {
|
||||
const states = get(menuSaveStates);
|
||||
return states.get(productCode)?.status ?? 'idle';
|
||||
}
|
||||
|
||||
export function isMenuSaving(productCode: string): boolean {
|
||||
return getMenuSaveStatus(productCode) === 'saving';
|
||||
}
|
||||
|
||||
export function isMenuSaved(productCode: string): boolean {
|
||||
return getMenuSaveStatus(productCode) === 'saved';
|
||||
}
|
||||
805
src/lib/core/stores/sheetStore.ts
Normal file
805
src/lib/core/stores/sheetStore.ts
Normal file
|
|
@ -0,0 +1,805 @@
|
|||
import { writable, get } from 'svelte/store';
|
||||
|
||||
// Catalog types
|
||||
export interface Catalog {
|
||||
catalog: string;
|
||||
row_index: number;
|
||||
status: 'free' | 'locked';
|
||||
locked_by: string | null;
|
||||
}
|
||||
|
||||
export interface CatalogsResponse {
|
||||
status: string;
|
||||
country: string;
|
||||
catalogs: Catalog[];
|
||||
}
|
||||
|
||||
export const sheetCatalogs = writable<Catalog[]>([]);
|
||||
export const sheetCatalogsLoading = writable<boolean>(false);
|
||||
|
||||
export const countryPrimaryLanguageMap: Record<string, string> = {
|
||||
THAI: 'Thai',
|
||||
tha: 'Thai',
|
||||
cocktail_tha: 'Thai',
|
||||
counter01: 'Thai',
|
||||
MYS: 'Malaysia',
|
||||
mys: 'Malaysia',
|
||||
IDR: 'Indonesian',
|
||||
idr: 'Indonesian',
|
||||
AUS: 'English',
|
||||
aus: 'English',
|
||||
USA_PEPSI: 'English',
|
||||
usa_pepsi: 'English',
|
||||
SG: 'English',
|
||||
SGP: 'English',
|
||||
sgp: 'English',
|
||||
UAE_DUBAI: 'Arabic',
|
||||
uae_dubai: 'Arabic',
|
||||
dubai: 'Arabic',
|
||||
HKG: 'Cantonese',
|
||||
hkg: 'Cantonese',
|
||||
GBR: 'English',
|
||||
gbr: 'English',
|
||||
LTU: 'Lithuanian',
|
||||
ltu: 'Lithuanian',
|
||||
ROU: 'Romanian',
|
||||
rou: 'Romanian',
|
||||
LVA: 'Latvian',
|
||||
lva: 'Latvian',
|
||||
EST: 'Estonian',
|
||||
est: 'Estonian'
|
||||
};
|
||||
|
||||
export function getCountryPrimaryLanguage(countryCode: string): string {
|
||||
return (
|
||||
countryPrimaryLanguageMap[countryCode] ??
|
||||
countryPrimaryLanguageMap[countryCode.toUpperCase()] ??
|
||||
'Unknown'
|
||||
);
|
||||
}
|
||||
|
||||
// Sheet column configuration by country for new_layout_v2
|
||||
// Maps language keys to column indices and product code columns
|
||||
export const SHEET_COLUMN_CONFIG_BY_COUNTRY: Record<string, {
|
||||
language: Record<string, number>;
|
||||
productCode: { hot: number; cold: number; blend: number };
|
||||
primaryLanguage: string;
|
||||
}> = {
|
||||
tha: {
|
||||
language: { en: 3, th: 4, zh: 5, my: 8 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'th'
|
||||
},
|
||||
aus: {
|
||||
language: { en: 3, th: 4 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'en'
|
||||
},
|
||||
gbr: {
|
||||
language: { en: 3 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'en'
|
||||
},
|
||||
hkg: {
|
||||
language: { en: 3, zh_hans: 4, zh_hant: 5, th: 6 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'zh_hant'
|
||||
},
|
||||
ltu: {
|
||||
language: { en: 3, th: 4, lt: 5, ro: 6 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'lt'
|
||||
},
|
||||
rou: {
|
||||
language: { en: 3, th: 4, lt: 5, ro: 6 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'ro'
|
||||
},
|
||||
lva: {
|
||||
language: { en: 3, th: 4, lt: 5, ro: 6 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'en'
|
||||
},
|
||||
est: {
|
||||
language: { en: 3, th: 4, lt: 5, ro: 6 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'en'
|
||||
},
|
||||
mys: {
|
||||
language: { en: 3, th: 4, ms: 7 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'ms'
|
||||
},
|
||||
sgp: {
|
||||
language: { en: 3, th: 4 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'en'
|
||||
},
|
||||
uae_dubai: {
|
||||
language: { en: 3, ar: 4 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'ar'
|
||||
},
|
||||
dubai: {
|
||||
language: { en: 3, ar: 4 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'ar'
|
||||
},
|
||||
default: {
|
||||
language: { en: 3, th: 4 },
|
||||
productCode: { hot: 9, cold: 10, blend: 11 },
|
||||
primaryLanguage: 'en'
|
||||
}
|
||||
};
|
||||
|
||||
export function getSheetColumnConfig(countryCode: string) {
|
||||
return SHEET_COLUMN_CONFIG_BY_COUNTRY[countryCode.toLowerCase()]
|
||||
|| SHEET_COLUMN_CONFIG_BY_COUNTRY.default;
|
||||
}
|
||||
|
||||
export function handleCatalogsResponse(content: CatalogsResponse) {
|
||||
if (content && content.catalogs) {
|
||||
sheetCatalogs.set(content.catalogs);
|
||||
}
|
||||
sheetCatalogsLoading.set(false);
|
||||
}
|
||||
|
||||
export interface SheetStreamMeta {
|
||||
batch_id: string;
|
||||
total_chunks: number;
|
||||
total_items: number;
|
||||
current_chunk: number;
|
||||
status: 'idle' | 'streaming' | 'complete' | 'error';
|
||||
error?: string;
|
||||
}
|
||||
|
||||
export interface SheetMenuItem {
|
||||
new_layout_v2: {
|
||||
row_index: number;
|
||||
cells: { value: string; coord: { row: number; col: number } }[];
|
||||
}[];
|
||||
name_desc_v2: {
|
||||
key: string;
|
||||
row_index: number;
|
||||
cells: { value: string; coord: { row: number; col: number } }[];
|
||||
}[];
|
||||
}
|
||||
|
||||
// Store for streaming metadata
|
||||
export const sheetStreamMeta = writable<SheetStreamMeta | null>(null);
|
||||
|
||||
// Store for accumulated sheet data
|
||||
export const sheetData = writable<SheetMenuItem[]>([]);
|
||||
|
||||
// Store for loading state
|
||||
export const sheetLoading = writable<boolean>(false);
|
||||
|
||||
// Store for error state
|
||||
export const sheetError = writable<string | null>(null);
|
||||
|
||||
// Handler functions for sheet-service streaming
|
||||
export function handleSheetStreamStart(payload: {
|
||||
batch_id: string;
|
||||
total_chunks: number;
|
||||
total_items: number;
|
||||
content: { message: string };
|
||||
}) {
|
||||
sheetStreamMeta.set({
|
||||
batch_id: payload.batch_id,
|
||||
total_chunks: payload.total_chunks,
|
||||
total_items: payload.total_items,
|
||||
current_chunk: 0,
|
||||
status: 'streaming'
|
||||
});
|
||||
sheetData.set([]);
|
||||
sheetLoading.set(true);
|
||||
sheetError.set(null);
|
||||
}
|
||||
|
||||
export function handleSheetStreamChunk(payload: {
|
||||
batch_id: string;
|
||||
current_chunk: number;
|
||||
total_chunks: number;
|
||||
total_items: number;
|
||||
content: SheetMenuItem[];
|
||||
}) {
|
||||
const meta = get(sheetStreamMeta);
|
||||
|
||||
// Verify batch_id matches
|
||||
if (meta && meta.batch_id === payload.batch_id) {
|
||||
// Append new data
|
||||
sheetData.update((current) => [...current, ...payload.content]);
|
||||
|
||||
// Update progress
|
||||
sheetStreamMeta.set({
|
||||
...meta,
|
||||
current_chunk: payload.current_chunk,
|
||||
total_chunks: payload.total_chunks,
|
||||
total_items: payload.total_items
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
export function handleSheetStreamEnd(payload: {
|
||||
batch_id: string;
|
||||
total_chunks: number;
|
||||
total_items: number;
|
||||
content: { message: string };
|
||||
}) {
|
||||
const meta = get(sheetStreamMeta);
|
||||
|
||||
if (meta && meta.batch_id === payload.batch_id) {
|
||||
sheetStreamMeta.set({
|
||||
...meta,
|
||||
status: 'complete',
|
||||
current_chunk: payload.total_chunks
|
||||
});
|
||||
sheetLoading.set(false);
|
||||
}
|
||||
}
|
||||
|
||||
export function handleSheetStreamError(payload: {
|
||||
batch_id: string;
|
||||
content: { error_detail: string };
|
||||
}) {
|
||||
const meta = get(sheetStreamMeta);
|
||||
|
||||
if (meta && meta.batch_id === payload.batch_id) {
|
||||
sheetStreamMeta.set({
|
||||
...meta,
|
||||
status: 'error',
|
||||
error: payload.content.error_detail
|
||||
});
|
||||
sheetError.set(payload.content.error_detail);
|
||||
sheetLoading.set(false);
|
||||
}
|
||||
}
|
||||
|
||||
// Reset all sheet stores
|
||||
export function resetSheetStore() {
|
||||
sheetStreamMeta.set(null);
|
||||
sheetData.set([]);
|
||||
sheetLoading.set(false);
|
||||
sheetError.set(null);
|
||||
}
|
||||
|
||||
// Store for existing product codes (for duplicate checking)
|
||||
export const existingProductCodes = writable<Set<string>>(new Set());
|
||||
export const productCodesLoading = writable<boolean>(false);
|
||||
|
||||
// ─────────────────────────────────────────
|
||||
// Sheet Price Streaming
|
||||
// ─────────────────────────────────────────
|
||||
|
||||
export interface GristCell {
|
||||
coord: {
|
||||
col: number;
|
||||
row: number;
|
||||
};
|
||||
value: string;
|
||||
}
|
||||
|
||||
export interface SheetPriceItem {
|
||||
product_code: string;
|
||||
cells: GristCell[];
|
||||
}
|
||||
|
||||
// Price sheet header name mappings by country
|
||||
// Maps our field names to the actual header names in the sheet
|
||||
export const PRICE_HEADER_NAMES_BY_COUNTRY: Record<string, {
|
||||
cash_price: string[]; // Possible header names for cash price
|
||||
non_cash_price: string[]; // Possible header names for non-cash price
|
||||
}> = {
|
||||
tha: {
|
||||
cash_price: ['Price'],
|
||||
non_cash_price: ['MainPrice']
|
||||
},
|
||||
mys: {
|
||||
cash_price: ['F', 'Price'],
|
||||
non_cash_price: ['MainPrice']
|
||||
},
|
||||
aus: {
|
||||
cash_price: ['AUD', 'Price'],
|
||||
non_cash_price: ['MainPrice']
|
||||
},
|
||||
sgp: {
|
||||
cash_price: ['SGD', 'Price'],
|
||||
non_cash_price: ['MainPrice']
|
||||
},
|
||||
hkg: {
|
||||
cash_price: ['HK Final Px', 'Price'],
|
||||
non_cash_price: ['MainPrice']
|
||||
},
|
||||
gbr: {
|
||||
cash_price: ['GBR', 'Price'],
|
||||
non_cash_price: ['MainPrice']
|
||||
},
|
||||
uae_dubai: {
|
||||
cash_price: ['AED', 'Price'],
|
||||
non_cash_price: ['MainPrice']
|
||||
},
|
||||
dubai: {
|
||||
cash_price: ['AED', 'Price'],
|
||||
non_cash_price: ['MainPrice']
|
||||
},
|
||||
ltu: {
|
||||
cash_price: ['Price in Euro', 'Price'],
|
||||
non_cash_price: ['MainPrice']
|
||||
},
|
||||
rou: {
|
||||
cash_price: ['Price From LTU (EUR)', 'Price in RON'],
|
||||
non_cash_price: ['MainPrice']
|
||||
},
|
||||
lva: {
|
||||
cash_price: ['Price in Euro', 'Price'],
|
||||
non_cash_price: ['MainPrice']
|
||||
},
|
||||
est: {
|
||||
cash_price: ['Price in Euro', 'Price'],
|
||||
non_cash_price: ['MainPrice']
|
||||
},
|
||||
// Default fallback for other countries
|
||||
default: {
|
||||
cash_price: ['Price', 'Price in Euro', 'CashPrice', 'AUD', 'SGD', 'GBR', 'AED', 'F'],
|
||||
non_cash_price: ['MainPrice', 'NonCashPrice']
|
||||
}
|
||||
};
|
||||
|
||||
// Find column index from header array by matching header names
|
||||
export function findHeaderIndex(headerArray: string[], possibleNames: string[]): number {
|
||||
for (const name of possibleNames) {
|
||||
const idx = headerArray.findIndex(h => h.toLowerCase() === name.toLowerCase());
|
||||
if (idx !== -1) {
|
||||
// Return col index (header index + 1 because cells start from col 1)
|
||||
return idx + 1;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Store: lastRequestSheetPrice[country][product_code] = cells (first row only, for display)
|
||||
export const lastRequestSheetPrice = writable<Record<string, Record<string, GristCell[]>>>({});
|
||||
|
||||
// Store: sheetPriceHeader[country] = header array
|
||||
export const sheetPriceHeader = writable<Record<string, string[]>>({});
|
||||
|
||||
// Store: sheetPriceAllRows[country][product_code] = array of {row, cells} (ALL rows for duplicates)
|
||||
export const sheetPriceAllRows = writable<Record<string, Record<string, { row: number; cells: GristCell[] }[]>>>({});
|
||||
|
||||
// Helper function to get price value from cells using dynamic header lookup
|
||||
export function getPriceFromCells(
|
||||
country: string,
|
||||
cells: GristCell[],
|
||||
priceType: 'cash_price' | 'non_cash_price' = 'cash_price'
|
||||
): string | null {
|
||||
const headers = get(sheetPriceHeader)[country];
|
||||
if (!headers || headers.length === 0) {
|
||||
console.warn(`[getPriceFromCells] No header found for country: ${country}`);
|
||||
return null;
|
||||
}
|
||||
|
||||
// Get possible header names for this country
|
||||
const headerNames = PRICE_HEADER_NAMES_BY_COUNTRY[country] || PRICE_HEADER_NAMES_BY_COUNTRY.default;
|
||||
const possibleNames = priceType === 'cash_price' ? headerNames.cash_price : headerNames.non_cash_price;
|
||||
|
||||
// Find the column index for this price type
|
||||
const colIdx = findHeaderIndex(headers, possibleNames);
|
||||
//console.log(`[getPriceFromCells] ${country} ${priceType}: colIdx=${colIdx}, headers=`, headers, 'possibleNames=', possibleNames);
|
||||
|
||||
if (colIdx < 0) {
|
||||
console.warn(`[getPriceFromCells] No ${priceType} column found for ${country}, tried:`, possibleNames);
|
||||
return null;
|
||||
}
|
||||
|
||||
// Find the cell with matching column index
|
||||
const priceCell = cells.find((c) => c.coord?.col === colIdx);
|
||||
//console.log(`[getPriceFromCells] Found cell for col ${colIdx}:`, priceCell);
|
||||
return priceCell?.value ?? null;
|
||||
}
|
||||
|
||||
// Store for tracking streaming state
|
||||
export const sheetPriceStreamMeta = writable<{
|
||||
request_id: string;
|
||||
country: string;
|
||||
status: 'idle' | 'streaming' | 'complete' | 'error';
|
||||
error?: string;
|
||||
} | null>(null);
|
||||
|
||||
export const sheetPriceLoading = writable<boolean>(false);
|
||||
|
||||
// Track sent request types (can only send once per type)
|
||||
export const sheetPriceSentTypes = writable<Set<string>>(new Set());
|
||||
|
||||
// Raw streaming data accumulator
|
||||
export const streamingRawData = writable<
|
||||
Record<
|
||||
string,
|
||||
{
|
||||
request_id: string;
|
||||
header?: string[];
|
||||
country?: string;
|
||||
chunks: any[];
|
||||
rawParts: string[]; // For accumulating raw JSON string parts
|
||||
}
|
||||
>
|
||||
>({});
|
||||
|
||||
// Handler: raw_stream header (e.g., raw_stream_price)
|
||||
export function handleRawStreamHeader(subtype: string, payload: any) {
|
||||
console.log(`[RawStream] Header for ${subtype}:`, payload);
|
||||
|
||||
// Get existing stream data to preserve country from request
|
||||
const currentData = get(streamingRawData);
|
||||
const existingData = currentData[subtype];
|
||||
|
||||
streamingRawData.update((data) => ({
|
||||
...data,
|
||||
[subtype]: {
|
||||
request_id: payload.request_id,
|
||||
header: payload.header || payload.headers,
|
||||
country: payload.country || existingData?.country || '',
|
||||
chunks: [],
|
||||
rawParts: [] // Initialize for accumulating raw JSON string parts
|
||||
}
|
||||
}));
|
||||
|
||||
if (subtype === 'price') {
|
||||
sheetPriceStreamMeta.set({
|
||||
request_id: payload.request_id,
|
||||
country: payload.country || existingData?.country || '',
|
||||
status: 'streaming'
|
||||
});
|
||||
sheetPriceLoading.set(true);
|
||||
}
|
||||
}
|
||||
|
||||
// Handler: raw_stream chunk (e.g., raw_stream_chunk_price)
|
||||
export function handleRawStreamChunk(subtype: string, payload: any) {
|
||||
console.log(`[RawStream] Chunk ${payload.idx} for ${subtype}, raw length:`, payload.raw?.length);
|
||||
|
||||
const currentData = get(streamingRawData);
|
||||
const streamData = currentData[subtype];
|
||||
|
||||
if (!streamData || streamData.request_id !== payload.request_id) {
|
||||
console.warn(`[RawStream] Chunk received for unknown stream: ${subtype}`);
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if data is in 'raw' field as JSON string (chunked)
|
||||
if (payload.raw && typeof payload.raw === 'string') {
|
||||
// Accumulate raw parts - will be joined and parsed in handleRawStreamEnd
|
||||
streamingRawData.update((data) => ({
|
||||
...data,
|
||||
[subtype]: {
|
||||
...streamData,
|
||||
country: payload.country || streamData.country,
|
||||
rawParts: [...(streamData.rawParts || []), payload.raw]
|
||||
}
|
||||
}));
|
||||
console.log(`[RawStream] Accumulated chunk ${payload.idx} for ${subtype}`);
|
||||
return;
|
||||
}
|
||||
|
||||
// Handle non-chunked payload (already parsed content)
|
||||
const content = payload.content || payload.data || payload.rows || [];
|
||||
const contentArray = Array.isArray(content) ? content : [content];
|
||||
|
||||
streamingRawData.update((data) => ({
|
||||
...data,
|
||||
[subtype]: {
|
||||
...streamData,
|
||||
country: payload.country || streamData.country,
|
||||
chunks: [...streamData.chunks, ...contentArray]
|
||||
}
|
||||
}));
|
||||
|
||||
console.log(`[RawStream] Chunk for ${subtype}: +${contentArray.length} items`);
|
||||
}
|
||||
|
||||
// Handler: raw_stream end (e.g., raw_stream_end_price)
|
||||
export function handleRawStreamEnd(subtype: string, payload: any) {
|
||||
console.log(`[RawStream] End payload for ${subtype}:`, payload);
|
||||
|
||||
const currentData = get(streamingRawData);
|
||||
const streamData = currentData[subtype];
|
||||
|
||||
if (!streamData || streamData.request_id !== payload.request_id) {
|
||||
console.warn(`[RawStream] End received for unknown stream: ${subtype}`);
|
||||
return;
|
||||
}
|
||||
|
||||
// Get country from stored stream data or payload
|
||||
const country = streamData.country || payload.country || '';
|
||||
|
||||
// If we have accumulated raw parts, join and parse them now
|
||||
let chunks = streamData.chunks || [];
|
||||
if (streamData.rawParts && streamData.rawParts.length > 0) {
|
||||
const fullRawJson = streamData.rawParts.join('');
|
||||
console.log(
|
||||
`[RawStream] Joining ${streamData.rawParts.length} raw parts, total length: ${fullRawJson.length}`
|
||||
);
|
||||
|
||||
try {
|
||||
const parsed = JSON.parse(fullRawJson);
|
||||
console.log(`[RawStream] Parsed combined raw data, keys:`, Object.keys(parsed));
|
||||
|
||||
// Extract content from nested structure: { payload: { content: [...] } }
|
||||
const content = parsed?.payload?.content || parsed?.content || parsed || [];
|
||||
chunks = Array.isArray(content) ? content : [content];
|
||||
|
||||
// Log first item to see actual structure
|
||||
if (chunks.length > 0) {
|
||||
console.log(`[RawStream] First content item:`, JSON.stringify(chunks[0]).substring(0, 200));
|
||||
}
|
||||
} catch (e) {
|
||||
console.error(`[RawStream] Failed to parse combined raw JSON:`, e);
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`[RawStream] End for ${subtype}: total ${chunks.length} items, country: ${country}`);
|
||||
|
||||
if (subtype === 'price') {
|
||||
processSheetPriceData(country, streamData.header || [], chunks);
|
||||
sheetPriceStreamMeta.update((meta) => (meta ? { ...meta, status: 'complete' } : null));
|
||||
sheetPriceLoading.set(false);
|
||||
}
|
||||
|
||||
// Clear the streaming data
|
||||
streamingRawData.update((data) => {
|
||||
const newData = { ...data };
|
||||
delete newData[subtype];
|
||||
return newData;
|
||||
});
|
||||
}
|
||||
|
||||
// Process and store sheet price data
|
||||
function processSheetPriceData(country: string, header: string[], chunks: any[]) {
|
||||
console.log(`[SheetPrice] Processing data for ${country}:`, {
|
||||
header,
|
||||
chunksCount: chunks.length
|
||||
});
|
||||
console.log(`[SheetPrice] Sample chunk:`, chunks[0]);
|
||||
|
||||
// Try to extract header from first chunk item if not provided separately
|
||||
// Backend sends header embedded in each item: { header: [...], key: "...", payload: [...] }
|
||||
let effectiveHeader = header;
|
||||
if ((!effectiveHeader || effectiveHeader.length === 0) && chunks.length > 0) {
|
||||
const firstChunk = chunks[0];
|
||||
if (firstChunk?.header && Array.isArray(firstChunk.header)) {
|
||||
effectiveHeader = firstChunk.header;
|
||||
console.log(`[SheetPrice] Extracted header from first chunk:`, effectiveHeader);
|
||||
}
|
||||
}
|
||||
|
||||
// Save header for dynamic column lookup later
|
||||
if (effectiveHeader && effectiveHeader.length > 0) {
|
||||
sheetPriceHeader.update((data) => ({
|
||||
...data,
|
||||
[country]: effectiveHeader
|
||||
}));
|
||||
console.log(`[SheetPrice] Saved header for ${country}:`, effectiveHeader);
|
||||
}
|
||||
|
||||
// Find column indices dynamically from header
|
||||
// product_code header is typically "ProductCode" or similar
|
||||
const productCodeIdx = findHeaderIndex(effectiveHeader, ['ProductCode', 'Product_Code', 'product_code', 'Code']);
|
||||
console.log(`[SheetPrice] productCodeIdx from header:`, productCodeIdx, 'header:', effectiveHeader);
|
||||
|
||||
const priceByProductCode: Record<string, GristCell[]> = {};
|
||||
// Track ALL rows per product code (for duplicates)
|
||||
const allRowsByProductCode: Record<string, { row: number; cells: GristCell[] }[]> = {};
|
||||
|
||||
for (const row of chunks) {
|
||||
if (!row) {
|
||||
console.log(`[SheetPrice] Row is null/undefined`);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Support new structure: {key, payload} where key=product_code
|
||||
// payload can be: [{cells: [...], row_index: ...}, ...] - multiple entries for duplicates
|
||||
if (row.key !== undefined) {
|
||||
const productCode = row.key;
|
||||
|
||||
// Handle payload structure - iterate ALL entries in payload for duplicates
|
||||
if (Array.isArray(row.payload) && row.payload.length > 0) {
|
||||
// Check if payload[0] has cells property (nested structure with row_index)
|
||||
if (row.payload[0]?.cells) {
|
||||
// payload: [{cells: [...], row_index: ...}, {cells: [...], row_index: ...}, ...]
|
||||
// Store first one for backward compatibility
|
||||
priceByProductCode[productCode] = row.payload[0].cells;
|
||||
|
||||
// Store ALL rows for duplicate handling
|
||||
if (!allRowsByProductCode[productCode]) {
|
||||
allRowsByProductCode[productCode] = [];
|
||||
}
|
||||
for (const entry of row.payload) {
|
||||
if (entry.cells && entry.row_index !== undefined) {
|
||||
allRowsByProductCode[productCode].push({
|
||||
row: entry.row_index,
|
||||
cells: entry.cells
|
||||
});
|
||||
}
|
||||
}
|
||||
} else if (row.payload[0]?.coord) {
|
||||
// payload: [{coord: {...}, value: ...}, ...] - flat cells array
|
||||
priceByProductCode[productCode] = row.payload;
|
||||
// Extract row from first cell's coord
|
||||
const rowNum = row.payload[0]?.coord?.row;
|
||||
if (rowNum !== undefined) {
|
||||
allRowsByProductCode[productCode] = [{ row: rowNum, cells: row.payload }];
|
||||
}
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// Fallback: Check if row has cells or if row itself is the cells array
|
||||
let cells: GristCell[] = row.cells || row;
|
||||
|
||||
if (!Array.isArray(cells)) {
|
||||
console.log(`[SheetPrice] Unknown row structure:`, row);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Find product_code from cells by column index
|
||||
if (productCodeIdx >= 0) {
|
||||
const productCodeCell = cells.find((c: GristCell) => c.coord?.col === productCodeIdx);
|
||||
const productCode = productCodeCell?.value;
|
||||
|
||||
if (productCode) {
|
||||
priceByProductCode[productCode] = cells;
|
||||
// Extract row from first cell's coord
|
||||
const rowNum = cells[0]?.coord?.row;
|
||||
if (rowNum !== undefined) {
|
||||
if (!allRowsByProductCode[productCode]) {
|
||||
allRowsByProductCode[productCode] = [];
|
||||
}
|
||||
allRowsByProductCode[productCode].push({ row: rowNum, cells });
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
lastRequestSheetPrice.update((data) => ({
|
||||
...data,
|
||||
[country]: {
|
||||
...(data[country] || {}),
|
||||
...priceByProductCode
|
||||
}
|
||||
}));
|
||||
|
||||
// Update sheetPriceAllRows for duplicate handling
|
||||
sheetPriceAllRows.update((data) => ({
|
||||
...data,
|
||||
[country]: {
|
||||
...(data[country] || {}),
|
||||
...allRowsByProductCode
|
||||
}
|
||||
}));
|
||||
|
||||
console.log(
|
||||
`[SheetPrice] Processed ${Object.keys(priceByProductCode).length} prices for ${country}`
|
||||
);
|
||||
console.log(`[SheetPrice] Sample product codes:`, Object.keys(priceByProductCode).slice(0, 5));
|
||||
// Log duplicates info
|
||||
const duplicates = Object.entries(allRowsByProductCode).filter(([_, rows]) => rows.length > 1);
|
||||
if (duplicates.length > 0) {
|
||||
console.log(`[SheetPrice] Found ${duplicates.length} product codes with duplicate rows:`, duplicates.slice(0, 3));
|
||||
}
|
||||
if (chunks.length > 0 && Object.keys(priceByProductCode).length > 0) {
|
||||
const sampleKey = Object.keys(priceByProductCode)[0];
|
||||
console.log(`[SheetPrice] Sample cells for ${sampleKey}:`, priceByProductCode[sampleKey]);
|
||||
}
|
||||
}
|
||||
|
||||
// Reset sheet price stores
|
||||
export function resetSheetPriceStore() {
|
||||
sheetPriceStreamMeta.set(null);
|
||||
sheetPriceLoading.set(false);
|
||||
streamingRawData.set({});
|
||||
}
|
||||
|
||||
// Check if a request type has already been sent
|
||||
export function hasSheetPriceBeenSent(type: string): boolean {
|
||||
return get(sheetPriceSentTypes).has(type);
|
||||
}
|
||||
|
||||
// Mark a request type as sent
|
||||
export function markSheetPriceAsSent(type: string) {
|
||||
sheetPriceSentTypes.update((types) => {
|
||||
const newTypes = new Set(types);
|
||||
newTypes.add(type);
|
||||
return newTypes;
|
||||
});
|
||||
}
|
||||
|
||||
// Clear sent types (for reset)
|
||||
export function clearSheetPriceSentTypes() {
|
||||
sheetPriceSentTypes.set(new Set());
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a newly generated product code to the store (local tracking before server sync)
|
||||
*/
|
||||
export function addGeneratedProductCode(code: string) {
|
||||
existingProductCodes.update((codes) => {
|
||||
const newSet = new Set(codes);
|
||||
newSet.add(code);
|
||||
return newSet;
|
||||
});
|
||||
console.log('[sheetStore] Added generated code:', code);
|
||||
}
|
||||
|
||||
const PRODUCT_CODES_STORAGE_KEY = 'supra_product_codes';
|
||||
|
||||
// Track current/pending country for product codes
|
||||
let currentProductCodesCountry = '';
|
||||
let pendingProductCodesCountry = '';
|
||||
|
||||
// Set pending country when making a request
|
||||
export function setPendingProductCodesCountry(country: string) {
|
||||
pendingProductCodesCountry = country;
|
||||
console.log('[sheetStore] Pending product codes country:', country);
|
||||
}
|
||||
|
||||
// Load product codes from localStorage for specific country
|
||||
export function loadProductCodesFromCache(country?: string): boolean {
|
||||
try {
|
||||
const cached = localStorage.getItem(PRODUCT_CODES_STORAGE_KEY);
|
||||
if (cached) {
|
||||
const data = JSON.parse(cached);
|
||||
// Only load if country matches (or no country filter specified)
|
||||
if (data.codes && Array.isArray(data.codes)) {
|
||||
if (country && data.country && data.country !== country) {
|
||||
console.log('[sheetStore] Cache is for different country:', data.country, '!= requested:', country);
|
||||
// Clear the store for different country
|
||||
existingProductCodes.set(new Set());
|
||||
return false;
|
||||
}
|
||||
existingProductCodes.set(new Set(data.codes));
|
||||
currentProductCodesCountry = data.country || '';
|
||||
console.log('[sheetStore] Loaded', data.codes.length, 'product codes from cache for', data.country || 'unknown');
|
||||
return true;
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
console.warn('[sheetStore] Failed to load from cache:', e);
|
||||
}
|
||||
// Clear store if no valid cache
|
||||
existingProductCodes.set(new Set());
|
||||
return false;
|
||||
}
|
||||
|
||||
// Clear product codes (call when switching countries)
|
||||
export function clearProductCodes() {
|
||||
existingProductCodes.set(new Set());
|
||||
currentProductCodesCountry = '';
|
||||
console.log('[sheetStore] Cleared product codes');
|
||||
}
|
||||
|
||||
export function handleListMenuResponse(payload: { codes: string[]; country?: string }) {
|
||||
// Use pending country if not in payload
|
||||
const country = payload.country || pendingProductCodesCountry;
|
||||
console.log('[sheetStore] Received list_menu_response for', country, ':', payload.codes?.length, 'codes');
|
||||
|
||||
if (payload && payload.codes) {
|
||||
existingProductCodes.set(new Set(payload.codes));
|
||||
currentProductCodesCountry = country;
|
||||
|
||||
// Save to localStorage with country
|
||||
try {
|
||||
localStorage.setItem(
|
||||
PRODUCT_CODES_STORAGE_KEY,
|
||||
JSON.stringify({
|
||||
codes: payload.codes,
|
||||
country: country,
|
||||
timestamp: Date.now()
|
||||
})
|
||||
);
|
||||
console.log('[sheetStore] Saved', payload.codes.length, 'product codes to cache for', country);
|
||||
} catch (e) {
|
||||
console.warn('[sheetStore] Failed to save to cache:', e);
|
||||
}
|
||||
}
|
||||
productCodesLoading.set(false);
|
||||
}
|
||||
|
|
@ -16,6 +16,38 @@ export const socketConnectionOfflineCount = writable<number>(0);
|
|||
export const socketAlreadySendHeartbeat = writable<number>(0);
|
||||
export const socketStore = writable<WebSocket | null>(null);
|
||||
|
||||
export function waitForOpenSocket(timeoutMs = 8000): Promise<WebSocket | null> {
|
||||
const currentSocket = get(socketStore);
|
||||
if (currentSocket?.readyState === WebSocket.OPEN) {
|
||||
return Promise.resolve(currentSocket);
|
||||
}
|
||||
|
||||
return new Promise((resolve) => {
|
||||
let settled = false;
|
||||
let unsubscribe = () => {};
|
||||
const timeout = setTimeout(() => {
|
||||
if (settled) return;
|
||||
settled = true;
|
||||
unsubscribe();
|
||||
resolve(null);
|
||||
}, timeoutMs);
|
||||
|
||||
function settle(nextSocket: WebSocket | null) {
|
||||
if (settled) return;
|
||||
settled = true;
|
||||
clearTimeout(timeout);
|
||||
unsubscribe();
|
||||
resolve(nextSocket);
|
||||
}
|
||||
|
||||
unsubscribe = socketStore.subscribe((nextSocket) => {
|
||||
if (nextSocket?.readyState === WebSocket.OPEN) {
|
||||
settle(nextSocket);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
export function connectToWebsocket(id_token?: string) {
|
||||
if (browser) {
|
||||
// console.log('connecting to ', env.PUBLIC_WSS);
|
||||
|
|
@ -41,6 +73,13 @@ export function connectToWebsocket(id_token?: string) {
|
|||
let auth_data = get(authStore);
|
||||
let perms = get(permission);
|
||||
|
||||
// Debug: check if auth_data has uid
|
||||
console.log('[WS Auth] Sending auth with:', {
|
||||
uid: auth_data?.uid,
|
||||
name: auth_data?.displayName,
|
||||
email: auth_data?.email
|
||||
});
|
||||
|
||||
sendMessage({
|
||||
type: 'auth',
|
||||
payload: {
|
||||
|
|
@ -53,6 +92,7 @@ export function connectToWebsocket(id_token?: string) {
|
|||
}
|
||||
});
|
||||
}
|
||||
console.log(socket);
|
||||
|
||||
// heartbeat 10s
|
||||
setInterval(() => {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue