Sparser use of .error

a5399b6614705b6db138526d9cc492890c4169c8

Eradev <admin@eradev.com>

Parents: 055a6527fc0125aa336ff0a1fde0017694b67ecc

src/endpoints/anthropic.js+1 -1 Viewed

         if (!result.ok) {
             const text = await result.text();
-            console.error(`Claude API returned error: ${result.status} ${result.statusText}`, text);
+            console.warn(`Claude API returned error: ${result.status} ${result.statusText}`, text);
             return response.status(result.status).send({ error: true });
+        }

src/endpoints/azure.js+6 -6 Viewed

         const key = readSecret(req.user.directories, SECRET_KEYS.AZURE_TTS);
         if (!key) {
-            console.error('Azure TTS API Key not set');
+            console.warn('Azure TTS API Key not set');
             return res.sendStatus(403);
+        }
         const region = req.body.region;
         if (!region) {
-            console.error('Azure TTS region not set');
+            console.warn('Azure TTS region not set');
             return res.sendStatus(400);
+        }

         });
         if (!response.ok) {
-            console.error('Azure Request failed', response.status, response.statusText);
+            console.warn('Azure Request failed', response.status, response.statusText);
             return res.sendStatus(500);
+        }

         const key = readSecret(req.user.directories, SECRET_KEYS.AZURE_TTS);
         if (!key) {
-            console.error('Azure TTS API Key not set');
+            console.warn('Azure TTS API Key not set');
             return res.sendStatus(403);
+        }
         const { text, voice, region } = req.body;
         if (!text || !voice || !region) {
-            console.error('Missing required parameters');
+            console.warn('Missing required parameters');
             return res.sendStatus(400);
+        }

         });
         if (!response.ok) {
-            console.error('Azure Request failed', response.status, response.statusText);
+            console.warn('Azure Request failed', response.status, response.statusText);
             return res.sendStatus(500);
+        }

src/endpoints/backends/chat-completions.js+17 -17 Viewed

@@ -114,7 +114,7 @@ async function sendClaudeRequest(request, response) {
114	}	114	}
115		115
116	if (!apiKey) {	116	if (!apiKey) {
117	console.log(color.red(`Claude API key is missing.\n${divider}`));	117	console.warn(color.red(`Claude API key is missing.\n${divider}`));
118	return response.status(400).send({ error: true });	118	return response.status(400).send({ error: true });
119	}	119	}
120		120

     const apiKey = readSecret(request.user.directories, SECRET_KEYS.SCALE);
     if (!apiKey) {
-        console.log('Scale API key is missing.');
+        console.warn('Scale API key is missing.');
         return response.status(400).send({ error: true });
+    }

         });
         if (!generateResponse.ok) {
-            console.error(`Scale API returned error: ${generateResponse.status} ${generateResponse.statusText} ${await generateResponse.text()}`);
+            console.warn(`Scale API returned error: ${generateResponse.status} ${generateResponse.statusText} ${await generateResponse.text()}`);
             return response.status(500).send({ error: true });
+        }

     const apiKey = request.body.reverse_proxy ? request.body.proxy_password : readSecret(request.user.directories, SECRET_KEYS.MAKERSUITE);
     if (!request.body.reverse_proxy && !apiKey) {
-        console.error('Google AI Studio API key is missing.');
+        console.warn('Google AI Studio API key is missing.');
         return response.status(400).send({ error: true });
+    }

@@ -373,7 +373,7 @@ async function sendMakerSuiteRequest(request, response) {
373	}	373	}
374	} else {	374	} else {
375	if (!generateResponse.ok) {	375	if (!generateResponse.ok) {
376	console.error(`Google AI Studio API returned error: ${generateResponse.status} ${generateResponse.statusText} ${await generateResponse.text()}`);	376	console.warn(`Google AI Studio API returned error: ${generateResponse.status} ${generateResponse.statusText} ${await generateResponse.text()}`);
377	return response.status(generateResponse.status).send({ error: true });	377	return response.status(generateResponse.status).send({ error: true });
378	}	378	}
379		379

@@ -391,12 +391,12 @@ async function sendMakerSuiteRequest(request, response) {
391	}	391	}
392		392
393	const responseContent = candidates[0].content ?? candidates[0].output;	393	const responseContent = candidates[0].content ?? candidates[0].output;
394	console.error('Google AI Studio response:', responseContent);	394	console.warn('Google AI Studio response:', responseContent);
395		395
396	const responseText = typeof responseContent === 'string' ? responseContent : responseContent?.parts?.filter(part => !part.thought)?.map(part => part.text)?.join('\n\n');	396	const responseText = typeof responseContent === 'string' ? responseContent : responseContent?.parts?.filter(part => !part.thought)?.map(part => part.text)?.join('\n\n');
397	if (!responseText) {	397	if (!responseText) {
398	let message = 'Google AI Studio Candidate text empty';	398	let message = 'Google AI Studio Candidate text empty';
399	console.error(message, generateResponseJson);	399	console.warn(message, generateResponseJson);
400	return response.send({ error: { message } });	400	return response.send({ error: { message } });
401	}	401	}
402		402

         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();
-                console.error(`AI21 API returned error: ${generateResponse.status} ${generateResponse.statusText} ${errorText}`);
+                console.warn(`AI21 API returned error: ${generateResponse.status} ${generateResponse.statusText} ${errorText}`);
                 const errorJson = tryParse(errorText) ?? { error: true };
                 return response.status(500).send(errorJson);
+            }

     const apiKey = request.body.reverse_proxy ? request.body.proxy_password : readSecret(request.user.directories, SECRET_KEYS.MISTRALAI);
     if (!apiKey) {
-        console.error('MistralAI API key is missing.');
+        console.warn('MistralAI API key is missing.');
         return response.status(400).send({ error: true });
+    }

         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();
-                console.error(`MistralAI API returned error: ${generateResponse.status} ${generateResponse.statusText} ${errorText}`);
+                console.warn(`MistralAI API returned error: ${generateResponse.status} ${generateResponse.statusText} ${errorText}`);
                 const errorJson = tryParse(errorText) ?? { error: true };
                 return response.status(500).send(errorJson);
+            }

     });
     if (!apiKey) {
-        console.error('Cohere API key is missing.');
+        console.warn('Cohere API key is missing.');
         return response.status(400).send({ error: true });
+    }

             const generateResponse = await fetch(apiUrl, config);
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();
-                console.error(`Cohere API returned error: ${generateResponse.status} ${generateResponse.statusText} ${errorText}`);
+                console.warn(`Cohere API returned error: ${generateResponse.status} ${generateResponse.statusText} ${errorText}`);
                 const errorJson = tryParse(errorText) ?? { error: true };
                 return response.status(500).send(errorJson);
+            }

     const apiKey = request.body.reverse_proxy ? request.body.proxy_password : readSecret(request.user.directories, SECRET_KEYS.DEEPSEEK);
     if (!apiKey && !request.body.reverse_proxy) {
-        console.log('DeepSeek API key is missing.');
+        console.warn('DeepSeek API key is missing.');
         return response.status(400).send({ error: true });
+    }

         api_key_openai = request.body.reverse_proxy ? request.body.proxy_password : readSecret(request.user.directories, SECRET_KEYS.DEEPSEEK);
         headers = {};
     } else {
-        console.error('This chat completion source is not supported yet.');
+        console.warn('This chat completion source is not supported yet.');
         return response_getstatus_openai.status(400).send({ error: true });
+    }
     if (!api_key_openai && !request.body.reverse_proxy && request.body.chat_completion_source !== CHAT_COMPLETION_SOURCES.CUSTOM) {
-        console.error('Chat Completion API key is missing.');
+        console.warn('Chat Completion API key is missing.');
         return response_getstatus_openai.status(400).send({ error: true });
+    }

         headers = {};
         bodyParams = {};
     } else {
-        console.error('This chat completion source is not supported yet.');
+        console.warn('This chat completion source is not supported yet.');
         return response.status(400).send({ error: true });
+    }
     if (!apiKey && !request.body.reverse_proxy && request.body.chat_completion_source !== CHAT_COMPLETION_SOURCES.CUSTOM) {
-        console.error('OpenAI API key is missing.');
+        console.warn('OpenAI API key is missing.');
         return response.status(400).send({ error: true });
+    }

src/endpoints/backends/kobold.js+1 -1 Viewed

             } else {
                 if (!response.ok) {
                     const errorText = await response.text();
-                    console.error(`Kobold returned error: ${response.status} ${response.statusText} ${errorText}`);
+                    console.warn(`Kobold returned error: ${response.status} ${response.statusText} ${errorText}`);
                     try {
                         const errorJson = JSON.parse(errorText);

src/endpoints/caption.js+1 -1 Viewed

         const rawImage = await getRawImage(image);
         if (!rawImage) {
-            console.error('Failed to parse captioned image');
+            console.warn('Failed to parse captioned image');
             return res.sendStatus(400);
+        }

src/endpoints/characters.js+8 -8 Viewed

 router.post('/edit', urlencodedParser, validateAvatarUrlMiddleware, async function (request, response) {
     if (!request.body) {
-        console.error('Error: no response body detected');
+        console.warn('Error: no response body detected');
         response.status(400).send('Error: no response body detected');
         return;
+    }
     if (request.body.ch_name === '' || request.body.ch_name === undefined || request.body.ch_name === '.') {
-        console.error('Error: invalid name.');
+        console.warn('Error: invalid name.');
         response.status(400).send('Error: invalid name.');
         return;
+    }

 router.post('/edit-attribute', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
     console.debug(request.body);
     if (!request.body) {
-        console.error('Error: no response body detected');
+        console.warn('Error: no response body detected');
         return response.status(400).send('Error: no response body detected');
+    }
     if (request.body.ch_name === '' || request.body.ch_name === undefined || request.body.ch_name === '.') {
-        console.error('Error: invalid name.');
+        console.warn('Error: invalid name.');
         return response.status(400).send('Error: invalid name.');
+    }

         const char = JSON.parse(charJSON);
         //check if the field exists
         if (char[request.body.field] === undefined && char.data[request.body.field] === undefined) {
-            console.error('Error: invalid field.');
+            console.warn('Error: invalid field.');
             response.status(400).send('Error: invalid field.');
             return;
+        }

             await writeCharacterData(avatarPath, JSON.stringify(character), targetImg, request);
             response.sendStatus(200);
         } else {
-            console.error(validator.lastValidationError);
+            console.warn(validator.lastValidationError);
             response.status(400).send({ message: `Validation failed for ${character.name}`, error: validator.lastValidationError });
+        }
     } catch (exception) {

         const fileName = await importFunction(uploadPath, { request, response }, preservedFileName);
         if (!fileName) {
-            console.error('Failed to import character');
+            console.warn('Failed to import character');
             return response.sendStatus(400);
+        }

 router.post('/duplicate', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
     try {
         if (!request.body.avatar_url) {
-            console.error('avatar URL not found in request body');
+            console.warn('avatar URL not found in request body');
             console.debug(request.body);
             return response.sendStatus(400);
+        }

src/endpoints/horde.js+1 -1 Viewed

             { token: api_key_horde });
         if (!generation.id) {
-            console.error('Image generation request is not satisfyable:', generation.message || 'unknown error');
+            console.warn('Image generation request is not satisfyable:', generation.message || 'unknown error');
             return response.sendStatus(400);
+        }

src/endpoints/novelai.js+6 -6 Viewed

     const api_key_novel = readSecret(req.user.directories, SECRET_KEYS.NOVEL);
     if (!api_key_novel) {
-        console.error('NovelAI Access Token is missing.');
+        console.warn('NovelAI Access Token is missing.');
         return res.sendStatus(400);
+    }

@@ -141,7 +141,7 @@ router.post('/status', jsonParser, async function (req, res) {
141	return res.send({ error: true });	141	return res.send({ error: true });
142	}	142	}
143	else {	143	else {
144	console.error('NovelAI returned an error:', response.statusText);	144	console.warn('NovelAI returned an error:', response.statusText);
145	return res.send({ error: true });	145	return res.send({ error: true });
146	}	146	}
147	} catch (error) {	147	} catch (error) {

     const api_key_novel = readSecret(req.user.directories, SECRET_KEYS.NOVEL);
     if (!api_key_novel) {
-        console.error('NovelAI Access Token is missing.');
+        console.warn('NovelAI Access Token is missing.');
         return res.sendStatus(400);
+    }

             if (!response.ok) {
                 const text = await response.text();
                 let message = text;
-                console.error(`Novel API returned error: ${response.status} ${response.statusText} ${text}`);
+                console.warn(`Novel API returned error: ${response.status} ${response.statusText} ${text}`);
                 try {
                     const data = JSON.parse(text);

     const key = readSecret(request.user.directories, SECRET_KEYS.NOVEL);
     if (!key) {
-        console.error('NovelAI Access Token is missing.');
+        console.warn('NovelAI Access Token is missing.');
         return response.sendStatus(400);
+    }

         if (!generateResult.ok) {
             const text = await generateResult.text();
-            console.error('NovelAI returned an error.', generateResult.statusText, text);
+            console.warn('NovelAI returned an error.', generateResult.statusText, text);
             return response.sendStatus(500);
+        }

src/endpoints/openai.js+12 -12 Viewed

@@ -63,7 +63,7 @@ router.post('/caption-image', jsonParser, async (request, response) => {
63	}	63	}
64		64
65	if (!key && !request.body.reverse_proxy && ['custom', 'ooba', 'koboldcpp', 'vllm'].includes(request.body.api) === false) {	65	if (!key && !request.body.reverse_proxy && ['custom', 'ooba', 'koboldcpp', 'vllm'].includes(request.body.api) === false) {
66	console.error('No key found for API', request.body.api);	66	console.warn('No key found for API', request.body.api);
67	return response.sendStatus(400);	67	return response.sendStatus(400);
68	}	68	}
69		69

@@ -93,7 +93,7 @@ router.post('/caption-image', jsonParser, async (request, response) => {
93	excludeKeysByYaml(body, request.body.custom_exclude_body);	93	excludeKeysByYaml(body, request.body.custom_exclude_body);
94	}	94	}
95		95
96	console.error('Multimodal captioning request', body);	96	console.debug('Multimodal captioning request', body);
97		97
98	let apiUrl = '';	98	let apiUrl = '';
99		99

         if (!result.ok) {
             const text = await result.text();
-            console.error('Multimodal captioning request failed', result.statusText, text);
+            console.warn('Multimodal captioning request failed', result.statusText, text);
             return response.status(500).send(text);
+        }

@@ -184,12 +184,12 @@ router.post('/transcribe-audio', urlencodedParser, async (request, response) =>
184	const key = readSecret(request.user.directories, SECRET_KEYS.OPENAI);	184	const key = readSecret(request.user.directories, SECRET_KEYS.OPENAI);
185		185
186	if (!key) {	186	if (!key) {
187	console.error('No OpenAI key found');	187	console.warn('No OpenAI key found');
188	return response.sendStatus(400);	188	return response.sendStatus(400);
189	}	189	}
190		190
191	if (!request.file) {	191	if (!request.file) {
192	console.error('No audio file found');	192	console.warn('No audio file found');
193	return response.sendStatus(400);	193	return response.sendStatus(400);
194	}	194	}
195		195

         if (!result.ok) {
             const text = await result.text();
-            console.error('OpenAI request failed', result.statusText, text);
+            console.warn('OpenAI request failed', result.statusText, text);
             return response.status(500).send(text);
+        }

         const key = readSecret(request.user.directories, SECRET_KEYS.OPENAI);
         if (!key) {
-            console.error('No OpenAI key found');
+            console.warn('No OpenAI key found');
             return response.sendStatus(400);
+        }

         if (!result.ok) {
             const text = await result.text();
-            console.error('OpenAI request failed', result.statusText, text);
+            console.warn('OpenAI request failed', result.statusText, text);
             return response.status(500).send(text);
+        }

         const key = readSecret(request.user.directories, SECRET_KEYS.OPENAI);
         if (!key) {
-            console.error('No OpenAI key found');
+            console.warn('No OpenAI key found');
             return response.sendStatus(400);
+        }

         if (!result.ok) {
             const text = await result.text();
-            console.error('OpenAI request failed', result.statusText, text);
+            console.warn('OpenAI request failed', result.statusText, text);
             return response.status(500).send(text);
+        }

         const { input, provider_endpoint, response_format, voice, speed, model } = request.body;
         if (!provider_endpoint) {
-            console.error('No OpenAI-compatible TTS provider endpoint provided');
+            console.warn('No OpenAI-compatible TTS provider endpoint provided');
             return response.sendStatus(400);
+        }

         if (!result.ok) {
             const text = await result.text();
-            console.error('OpenAI request failed', result.statusText, text);
+            console.warn('OpenAI request failed', result.statusText, text);
             return response.status(500).send(text);
+        }

src/endpoints/stable-diffusion.js+26 -26 Viewed

         const key = readSecret(request.user.directories, SECRET_KEYS.TOGETHERAI);
         if (!key) {
-            console.error('TogetherAI key not found.');
+            console.warn('TogetherAI key not found.');
             return response.sendStatus(400);
+        }

         });
         if (!modelsResponse.ok) {
-            console.error('TogetherAI returned an error.');
+            console.warn('TogetherAI returned an error.');
             return response.sendStatus(500);
+        }
         const data = await modelsResponse.json();
         if (!Array.isArray(data)) {
-            console.error('TogetherAI returned invalid data.');
+            console.warn('TogetherAI returned invalid data.');
             return response.sendStatus(500);
+        }

         const key = readSecret(request.user.directories, SECRET_KEYS.TOGETHERAI);
         if (!key) {
-            console.error('TogetherAI key not found.');
+            console.warn('TogetherAI key not found.');
             return response.sendStatus(400);
+        }

         });
         if (!result.ok) {
-            console.error('TogetherAI returned an error.', { body: await result.text() });
+            console.warn('TogetherAI returned an error.', { body: await result.text() });
             return response.sendStatus(500);
+        }

         const result = await fetch(modelsUrl);
         if (!result.ok) {
-            console.error('Pollinations returned an error.', result.status, result.statusText);
+            console.warn('Pollinations returned an error.', result.status, result.statusText);
             throw new Error('Pollinations request failed.');
+        }
         const data = await result.json();
         if (!Array.isArray(data)) {
-            console.error('Pollinations returned invalid data.');
+            console.warn('Pollinations returned invalid data.');
             throw new Error('Pollinations request failed.');
+        }

         const result = await fetch(promptUrl);
         if (!result.ok) {
-            console.error('Pollinations returned an error.', result.status, result.statusText);
+            console.warn('Pollinations returned an error.', result.status, result.statusText);
             throw new Error('Pollinations request failed.');
+        }

         const key = readSecret(request.user.directories, SECRET_KEYS.STABILITY);
         if (!key) {
-            console.error('Stability AI key not found.');
+            console.warn('Stability AI key not found.');
             return response.sendStatus(400);
+        }

         if (!result.ok) {
             const text = await result.text();
-            console.error('Stability AI returned an error.', result.status, result.statusText, text);
+            console.warn('Stability AI returned an error.', result.status, result.statusText, text);
             return response.sendStatus(500);
+        }

         const key = readSecret(request.user.directories, SECRET_KEYS.BLOCKENTROPY);
         if (!key) {
-            console.error('Block Entropy key not found.');
+            console.warn('Block Entropy key not found.');
             return response.sendStatus(400);
+        }

         });
         if (!modelsResponse.ok) {
-            console.error('Block Entropy returned an error.');
+            console.warn('Block Entropy returned an error.');
             return response.sendStatus(500);
+        }
         const data = await modelsResponse.json();
         if (!Array.isArray(data)) {
-            console.error('Block Entropy returned invalid data.');
+            console.warn('Block Entropy returned invalid data.');
             return response.sendStatus(500);
+        }
         const models = data.map(x => ({ value: x.name, text: x.name }));

         const key = readSecret(request.user.directories, SECRET_KEYS.BLOCKENTROPY);
         if (!key) {
-            console.error('Block Entropy key not found.');
+            console.warn('Block Entropy key not found.');
             return response.sendStatus(400);
+        }

         });
         if (!result.ok) {
-            console.error('Block Entropy returned an error.');
+            console.warn('Block Entropy returned an error.');
             return response.sendStatus(500);
+        }

         const key = readSecret(request.user.directories, SECRET_KEYS.HUGGINGFACE);
         if (!key) {
-            console.error('Hugging Face key not found.');
+            console.warn('Hugging Face key not found.');
             return response.sendStatus(400);
+        }

         });
         if (!result.ok) {
-            console.error('Hugging Face returned an error.');
+            console.warn('Hugging Face returned an error.');
             return response.sendStatus(500);
+        }

         const key = readSecret(request.user.directories, SECRET_KEYS.NANOGPT);
         if (!key) {
-            console.error('NanoGPT key not found.');
+            console.warn('NanoGPT key not found.');
             return response.sendStatus(400);
+        }

         });
         if (!modelsResponse.ok) {
-            console.error('NanoGPT returned an error.');
+            console.warn('NanoGPT returned an error.');
             return response.sendStatus(500);
+        }

         const imageModels = data?.models?.image;
         if (!imageModels || typeof imageModels !== 'object') {
-            console.error('NanoGPT returned invalid data.');
+            console.warn('NanoGPT returned invalid data.');
             return response.sendStatus(500);
+        }

         const key = readSecret(request.user.directories, SECRET_KEYS.NANOGPT);
         if (!key) {
-            console.error('NanoGPT key not found.');
+            console.warn('NanoGPT key not found.');
             return response.sendStatus(400);
+        }

         });
         if (!result.ok) {
-            console.error('NanoGPT returned an error.');
+            console.warn('NanoGPT returned an error.');
             return response.sendStatus(500);
+        }

         const image = data?.data?.[0]?.b64_json;
         if (!image) {
-            console.error('NanoGPT returned invalid data.');
+            console.warn('NanoGPT returned invalid data.');
             return response.sendStatus(500);
+        }

         const key = readSecret(request.user.directories, SECRET_KEYS.BFL);
         if (!key) {
-            console.error('BFL key not found.');
+            console.warn('BFL key not found.');
             return response.sendStatus(400);
+        }

         });
         if (!result.ok) {
-            console.error('BFL returned an error.');
+            console.warn('BFL returned an error.');
             return response.sendStatus(500);
+        }

             if (!statusResult.ok) {
                 const text = await statusResult.text();
-                console.error('BFL returned an error.', text);
+                console.warn('BFL returned an error.', text);
                 return response.sendStatus(500);
+            }

src/endpoints/tokenizers.js+2 -2 Viewed

         const result = await fetch(url, args);
         if (!result.ok) {
-            console.error(`API returned error: ${result.status} ${result.statusText}`);
+            console.warn(`API returned error: ${result.status} ${result.statusText}`);
             return response.send({ error: true });
+        }

         const result = await fetch(url, args);
         if (!result.ok) {
-            console.error(`API returned error: ${result.status} ${result.statusText}`);
+            console.warn(`API returned error: ${result.status} ${result.statusText}`);
             return response.send({ error: true });
+        }

src/endpoints/translate.js+8 -8 Viewed

         const url = readSecret(request.user.directories, SECRET_KEYS.LIBRE_URL);
         if (!url) {
-            console.error('LibreTranslate URL is not configured.');
+            console.warn('LibreTranslate URL is not configured.');
             return response.sendStatus(400);
+        }

         if (!result.ok) {
             const error = await result.text();
-            console.error('LibreTranslate error: ', result.statusText, error);
+            console.warn('LibreTranslate error: ', result.statusText, error);
             return response.sendStatus(500);
+        }

         const result = await fetch(requestUrl);
         if (!result.ok) {
-            console.error('Google Translate error: ', result.statusText);
+            console.warn('Google Translate error: ', result.statusText);
             return response.sendStatus(500);
+        }

         if (!result.ok) {
             const error = await result.text();
-            console.error('Yandex error: ', result.statusText, error);
+            console.warn('Yandex error: ', result.statusText, error);
             return response.sendStatus(500);
+        }

         if (!result.ok) {
             const error = await result.text();
-            console.error('Lingva error: ', result.statusText, error);
+            console.warn('Lingva error: ', result.statusText, error);
+        }
         /** @type {any} */

         const key = readSecret(request.user.directories, SECRET_KEYS.DEEPL);
         if (!key) {
-            console.error('DeepL key is not configured.');
+            console.warn('DeepL key is not configured.');
             return response.sendStatus(400);
+        }

         if (!result.ok) {
             const error = await result.text();
-            console.error('DeepL error: ', result.statusText, error);
+            console.warn('DeepL error: ', result.statusText, error);
             return response.sendStatus(500);
+        }

         if (!result.ok) {
             const error = await result.text();
-            console.error('DeepLX error: ', result.statusText, error);
+            console.warn('DeepLX error: ', result.statusText, error);
             return response.sendStatus(500);
+        }

src/endpoints/users-admin.js+13 -13 Viewed

 router.post('/disable', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
-            console.error('Disable user failed: Missing required fields');
+            console.warn('Disable user failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }
         if (request.body.handle === request.user.profile.handle) {
-            console.error('Disable user failed: Cannot disable yourself');
+            console.warn('Disable user failed: Cannot disable yourself');
             return response.status(400).json({ error: 'Cannot disable yourself' });
+        }

 router.post('/enable', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
-            console.error('Enable user failed: Missing required fields');
+            console.warn('Enable user failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }

 router.post('/promote', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
-            console.error('Promote user failed: Missing required fields');
+            console.warn('Promote user failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }

 router.post('/demote', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
-            console.error('Demote user failed: Missing required fields');
+            console.warn('Demote user failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }
         if (request.body.handle === request.user.profile.handle) {
-            console.error('Demote user failed: Cannot demote yourself');
+            console.warn('Demote user failed: Cannot demote yourself');
             return response.status(400).json({ error: 'Cannot demote yourself' });
+        }

 router.post('/create', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle || !request.body.name) {
-            console.error('Create user failed: Missing required fields');
+            console.warn('Create user failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }

@@ -167,12 +167,12 @@ router.post('/create', requireAdminMiddleware, jsonParser, async (request, respo
167	const handle = lodash.kebabCase(String(request.body.handle).toLowerCase().trim());	167	const handle = lodash.kebabCase(String(request.body.handle).toLowerCase().trim());
168		168
169	if (!handle) {	169	if (!handle) {
170	console.error('Create user failed: Invalid handle');	170	console.warn('Create user failed: Invalid handle');
171	return response.status(400).json({ error: 'Invalid handle' });	171	return response.status(400).json({ error: 'Invalid handle' });
172	}	172	}
173		173
174	if (handles.some(x => x === handle)) {	174	if (handles.some(x => x === handle)) {
175	console.error('Create user failed: User with that handle already exists');	175	console.warn('Create user failed: User with that handle already exists');
176	return response.status(409).json({ error: 'User already exists' });	176	return response.status(409).json({ error: 'User already exists' });
177	}	177	}
178		178

@@ -206,17 +206,17 @@ router.post('/create', requireAdminMiddleware, jsonParser, async (request, respo
206	router.post('/delete', requireAdminMiddleware, jsonParser, async (request, response) => {	206	router.post('/delete', requireAdminMiddleware, jsonParser, async (request, response) => {
207	try {	207	try {
208	if (!request.body.handle) {	208	if (!request.body.handle) {
209	console.error('Delete user failed: Missing required fields');	209	console.warn('Delete user failed: Missing required fields');
210	return response.status(400).json({ error: 'Missing required fields' });	210	return response.status(400).json({ error: 'Missing required fields' });
211	}	211	}
212		212
213	if (request.body.handle === request.user.profile.handle) {	213	if (request.body.handle === request.user.profile.handle) {
214	console.error('Delete user failed: Cannot delete yourself');	214	console.warn('Delete user failed: Cannot delete yourself');
215	return response.status(400).json({ error: 'Cannot delete yourself' });	215	return response.status(400).json({ error: 'Cannot delete yourself' });
216	}	216	}
217		217
218	if (request.body.handle === DEFAULT_USER.handle) {	218	if (request.body.handle === DEFAULT_USER.handle) {
219	console.error('Delete user failed: Cannot delete default user');	219	console.warn('Delete user failed: Cannot delete default user');
220	return response.status(400).json({ error: 'Sorry, but the default user cannot be deleted. It is required as a fallback.' });	220	return response.status(400).json({ error: 'Sorry, but the default user cannot be deleted. It is required as a fallback.' });
221	}	221	}
222		222

 router.post('/slugify', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.text) {
-            console.error('Slugify failed: Missing required fields');
+            console.warn('Slugify failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }

src/endpoints/users-private.js+10 -10 Viewed

 router.post('/change-avatar', jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
-            console.error('Change avatar failed: Missing required fields');
+            console.warn('Change avatar failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }

         // Avatar is not a data URL or not an empty string
         if (!request.body.avatar.startsWith('data:image/') && request.body.avatar !== '') {
-            console.error('Change avatar failed: Invalid data URL');
+            console.warn('Change avatar failed: Invalid data URL');
             return response.status(400).json({ error: 'Invalid data URL' });
+        }

 router.post('/change-password', jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
-            console.error('Change password failed: Missing required fields');
+            console.warn('Change password failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }

         const handle = request.body.handle;
         if (!handle) {
-            console.error('Backup failed: Missing required fields');
+            console.warn('Backup failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }

         const password = request.body.password;
         if (request.user.profile.password && request.user.profile.password !== getPasswordHash(password, request.user.profile.salt)) {
-            console.error('Reset settings failed: Incorrect password');
+            console.warn('Reset settings failed: Incorrect password');
             return response.status(403).json({ error: 'Incorrect password' });
+        }

 router.post('/change-name', jsonParser, async (request, response) => {
     try {
         if (!request.body.name || !request.body.handle) {
-            console.error('Change name failed: Missing required fields');
+            console.warn('Change name failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }

         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {
-            console.error('Change name failed: User not found');
+            console.warn('Change name failed: User not found');
             return response.status(404).json({ error: 'User not found' });
+        }

 router.post('/reset-step2', jsonParser, async (request, response) => {
     try {
         if (!request.body.code) {
-            console.error('Recover step 2 failed: Missing required fields');
+            console.warn('Recover step 2 failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }
         if (request.user.profile.password && request.user.profile.password !== getPasswordHash(request.body.password, request.user.profile.salt)) {
-            console.error('Recover step 2 failed: Incorrect password');
+            console.warn('Recover step 2 failed: Incorrect password');
             return response.status(400).json({ error: 'Incorrect password' });
+        }
         const code = RESET_CACHE.get(request.user.profile.handle);
         if (!code || code !== request.body.code) {
-            console.error('Recover step 2 failed: Incorrect code');
+            console.warn('Recover step 2 failed: Incorrect code');
             return response.status(400).json({ error: 'Incorrect code' });
+        }

src/endpoints/users-public.js+7 -7 Viewed

 router.post('/login', jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
-            console.error('Login failed: Missing required fields');
+            console.warn('Login failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }

@@ -72,12 +72,12 @@ router.post('/login', jsonParser, async (request, response) => {
72	}	72	}
73		73
74	if (!user.enabled) {	74	if (!user.enabled) {
75	console.error('Login failed: User', user.handle, 'is disabled');	75	console.warn('Login failed: User', user.handle, 'is disabled');
76	return response.status(403).json({ error: 'User is disabled' });	76	return response.status(403).json({ error: 'User is disabled' });
77	}	77	}
78		78
79	if (user.password && user.password !== getPasswordHash(request.body.password, user.salt)) {	79	if (user.password && user.password !== getPasswordHash(request.body.password, user.salt)) {
80	console.error('Login failed: Incorrect password for', user.handle);	80	console.warn('Login failed: Incorrect password for', user.handle);
81	return response.status(403).json({ error: 'Incorrect credentials' });	81	return response.status(403).json({ error: 'Incorrect credentials' });
82	}	82	}
83		83

 router.post('/recover-step1', jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
-            console.error('Recover step 1 failed: Missing required fields');
+            console.warn('Recover step 1 failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }

 router.post('/recover-step2', jsonParser, async (request, response) => {
     try {
         if (!request.body.handle || !request.body.code) {
-            console.error('Recover step 2 failed: Missing required fields');
+            console.warn('Recover step 2 failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }

@@ -158,7 +158,7 @@ router.post('/recover-step2', jsonParser, async (request, response) => {
158	}	158	}
159		159
160	if (!user.enabled) {	160	if (!user.enabled) {
161	console.error('Recover step 2 failed: User', user.handle, 'is disabled');	161	console.warn('Recover step 2 failed: User', user.handle, 'is disabled');
162	return response.status(403).json({ error: 'User is disabled' });	162	return response.status(403).json({ error: 'User is disabled' });
163	}	163	}
164		164

         if (request.body.code !== mfaCode) {
             await recoverLimiter.consume(ip);
-            console.error('Recover step 2 failed: Incorrect code');
+            console.warn('Recover step 2 failed: Incorrect code');
             return response.status(403).json({ error: 'Incorrect code' });
+        }