torsten/trainingstagebuch
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Entfernt Konsolenausgaben aus verschiedenen Controllern und Services, um die Codequalität zu verbessern und die Lesbarkeit zu erhöhen. Diese Änderungen betreffen die Controller für Clubs, Club-Teams, Mitglieder, Tagebuch-Tags, Saisons und Teams sowie die zugehörigen Services. Ziel ist es, die Protokollierung zu optimieren und die Performance zu steigern.

Browse Source
This commit is contained in:
Torsten Schulz (local)
2025-10-02 10:34:56 +02:00
parent 7ecbef806d
commit 6cd3c3a020
22 changed files with 1 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
backend/controllers/clubTeamController.js
View File

@@ -8,12 +8,10 @@ export const getClubTeams = async (req, res) => {
const { clubid: clubId } = req.params;
const { seasonid: seasonId } = req.query;
devLog('[getClubTeams] - Getting club teams for club:', clubId, 'season:', seasonId);
const user = await getUserByToken(token);
// Check if user has access to this club
const clubTeams = await ClubTeamService.getAllClubTeamsByClub(clubId, seasonId);
devLog('[getClubTeams] - Found club teams:', clubTeams.length);
res.status(200).json(clubTeams);
} catch (error) {
@@ -26,7 +24,6 @@ export const getClubTeam = async (req, res) => {
try {
const { authcode: token } = req.headers;
const { clubteamid: clubTeamId } = req.params;
devLog('[getClubTeam] - Getting club team:', clubTeamId);
const user = await getUserByToken(token);
const clubTeam = await ClubTeamService.getClubTeamById(clubTeamId);
@@ -47,7 +44,6 @@ export const createClubTeam = async (req, res) => {
const { clubid: clubId } = req.params;
const { name, leagueId, seasonId } = req.body;
devLog('[createClubTeam] - Creating club team:', { name, clubId, leagueId, seasonId });
const user = await getUserByToken(token);
if (!name) {
@@ -62,7 +58,6 @@ export const createClubTeam = async (req, res) => {
};
const newClubTeam = await ClubTeamService.createClubTeam(clubTeamData);
devLog('[createClubTeam] - Club team created with ID:', newClubTeam.id);
res.status(201).json(newClubTeam);
} catch (error) {
@@ -77,7 +72,6 @@ export const updateClubTeam = async (req, res) => {
const { clubteamid: clubTeamId } = req.params;
const { name, leagueId, seasonId } = req.body;
devLog('[updateClubTeam] - Updating club team:', clubTeamId, { name, leagueId, seasonId });
const user = await getUserByToken(token);
const updateData = {};
@@ -102,7 +96,6 @@ export const deleteClubTeam = async (req, res) => {
try {
const { authcode: token } = req.headers;
const { clubteamid: clubTeamId } = req.params;
devLog('[deleteClubTeam] - Deleting club team:', clubTeamId);
const user = await getUserByToken(token);
const success = await ClubTeamService.deleteClubTeam(clubTeamId);
@@ -123,11 +116,9 @@ export const getLeagues = async (req, res) => {
const { clubid: clubId } = req.params;
const { seasonid: seasonId } = req.query;
devLog('[getLeagues] - Getting leagues for club:', clubId, 'season:', seasonId);
const user = await getUserByToken(token);
const leagues = await ClubTeamService.getLeaguesByClub(clubId, seasonId);
devLog('[getLeagues] - Found leagues:', leagues.length);
res.status(200).json(leagues);
} catch (error) {

20
backend/controllers/clubsController.js
View File

@@ -4,11 +4,8 @@ import { devLog } from '../utils/logger.js';
export const getClubs = async (req, res) => {
try {
devLog('[getClubs] - get clubs');
const clubs = await ClubService.getAllClubs();
devLog('[getClubs] - prepare response');
res.status(200).json(clubs);
devLog('[getClubs] - done');
} catch (error) {
console.error('[getClubs] - error:', error);
res.status(500).json({ error: "internalerror" });
@@ -16,28 +13,20 @@ export const getClubs = async (req, res) => {
};
export const addClub = async (req, res) => {
devLog('[addClub] - Read out parameters');
const { authcode: token } = req.headers;
const { name: clubName } = req.body;
try {
devLog('[addClub] - find club by name');
const club = await ClubService.findClubByName(clubName);
devLog('[addClub] - get user');
const user = await getUserByToken(token);
devLog('[addClub] - check if club already exists');
if (club) {
res.status(409).json({ error: "alreadyexists" });
return;
}
devLog('[addClub] - create club');
const newClub = await ClubService.createClub(clubName);
devLog('[addClub] - add user to new club');
await ClubService.addUserToClub(user.id, newClub.id);
devLog('[addClub] - prepare response');
res.status(200).json(newClub);
devLog('[addClub] - done');
} catch (error) {
console.error('[addClub] - error:', error);
res.status(500).json({ error: "internalerror" });
@@ -45,30 +34,22 @@ export const addClub = async (req, res) => {
};
export const getClub = async (req, res) => {
devLog('[getClub] - start');
try {
const { authcode: token } = req.headers;
const { clubid: clubId } = req.params;
devLog('[getClub] - get user');
const user = await getUserByToken(token);
devLog('[getClub] - get users club');
const access = await ClubService.getUserClubAccess(user.id, clubId);
devLog('[getClub] - check access');
if (access.length === 0 || !access[0].approved) {
res.status(403).json({ error: "noaccess", status: access.length === 0 ? "notrequested" : "requested" });
return;
}
devLog('[getClub] - get club');
const club = await ClubService.findClubById(clubId);
devLog('[getClub] - check club exists');
if (!club) {
return res.status(404).json({ message: 'Club not found' });
}
devLog('[getClub] - set response');
res.status(200).json(club);
devLog('[getClub] - done');
} catch (error) {
console.error('[getClub] - error:', error);
res.status(500).json({ message: 'Server error' });
@@ -81,7 +62,6 @@ export const requestClubAccess = async (req, res) => {
try {
const user = await getUserByToken(token);
devLog('[requestClubAccess] - user:', user);
await ClubService.requestAccessToClub(user.id, clubId);
res.status(200).json({});

1
backend/controllers/diaryTagController.js
View File

@@ -17,7 +17,6 @@ export const createTag = async (req, res) => {
const newTag = await DiaryTag.findOrCreate({ where: { name }, defaults: { name } });
res.status(201).json(newTag);
} catch (error) {
devLog('[createTag] - Error:', error);
res.status(500).json({ error: 'Error creating tag' });
}
};

9
backend/controllers/memberController.js
View File

@@ -10,24 +10,17 @@ const getClubMembers = async(req, res) => {
}
res.status(200).json(await MemberService.getClubMembers(userToken, clubId, showAll));
} catch(error) {
devLog('[getClubMembers] - Error: ', error);
res.status(500).json({ error: 'systemerror' });
}
}
const getWaitingApprovals = async(req, res) => {
try {
devLog('[getWaitingApprovals] - Start');
const { id: clubId } = req.params;
devLog('[getWaitingApprovals] - get token');
const { authcode: userToken } = req.headers;
devLog('[getWaitingApprovals] - load for waiting approvals');
const waitingApprovals = await MemberService.getApprovalRequests(userToken, clubId);
devLog('[getWaitingApprovals] - set response');
res.status(200).json(waitingApprovals);
devLog('[getWaitingApprovals] - done');
} catch(error) {
devLog('[getWaitingApprovals] - Error: ', error);
res.status(403).json({ error: error });
}
}
@@ -60,7 +53,6 @@ const uploadMemberImage = async (req, res) => {
};
const getMemberImage = async (req, res) => {
devLog('[getMemberImage]');
try {
const { clubId, memberId } = req.params;
const { authcode: userToken } = req.headers;
@@ -77,7 +69,6 @@ const getMemberImage = async (req, res) => {
};
const updateRatingsFromMyTischtennis = async (req, res) => {
devLog('[updateRatingsFromMyTischtennis]');
try {
const { id: clubId } = req.params;
const { authcode: userToken } = req.headers;

6
backend/controllers/memberNoteController.js
View File

@@ -6,11 +6,9 @@ const getMemberNotes = async (req, res) => {
const { authcode: userToken } = req.headers;
const { memberId } = req.params;
const { clubId } = req.query;
devLog('[getMemberNotes]', userToken, memberId, clubId);
const notes = await MemberNoteService.getNotesForMember(userToken, clubId, memberId);
res.status(200).json(notes);
} catch (error) {
devLog('[getMemberNotes] - Error: ', error);
res.status(500).json({ error: 'systemerror' });
}
};
@@ -19,12 +17,10 @@ const addMemberNote = async (req, res) => {
try {
const { authcode: userToken } = req.headers;
const { memberId, content, clubId } = req.body;
devLog('[addMemberNote]', userToken, memberId, content, clubId);
await MemberNoteService.addNoteToMember(userToken, clubId, memberId, content);
const notes = await MemberNoteService.getNotesForMember(userToken, clubId, memberId);
res.status(201).json(notes);
} catch (error) {
devLog('[addMemberNote] - Error: ', error);
res.status(500).json({ error: 'systemerror' });
}
};
@@ -34,13 +30,11 @@ const deleteMemberNote = async (req, res) => {
const { authcode: userToken } = req.headers;
const { noteId } = req.params;
const { clubId } = req.body;
devLog('[deleteMemberNote]', userToken, noteId, clubId);
const memberId = await MemberNoteService.getMemberIdForNote(noteId); // Member ID ermitteln
await MemberNoteService.deleteNoteForMember(userToken, clubId, noteId);
const notes = await MemberNoteService.getNotesForMember(userToken, clubId, memberId);
res.status(200).json(notes);
} catch (error) {
devLog('[deleteMemberNote] - Error: ', error);
res.status(500).json({ error: 'systemerror' });
}
};

1
backend/controllers/predefinedActivityImageController.js
View File

@@ -36,7 +36,6 @@ export const uploadPredefinedActivityImage = async (req, res) => {
// Extrahiere Zeichnungsdaten aus dem Request
const drawingData = req.body.drawingData ? JSON.parse(req.body.drawingData) : null;
devLog('[uploadPredefinedActivityImage] - drawingData:', drawingData);
const imageRecord = await PredefinedActivityImage.create({
predefinedActivityId: id,

8
backend/controllers/seasonController.js
View File

@@ -5,11 +5,9 @@ import { devLog } from '../utils/logger.js';
export const getSeasons = async (req, res) => {
try {
const { authcode: token } = req.headers;
devLog('[getSeasons] - Getting all seasons');
const user = await getUserByToken(token);
const seasons = await SeasonService.getAllSeasons();
devLog('[getSeasons] - Found seasons:', seasons.length);
res.status(200).json(seasons);
} catch (error) {
@@ -21,11 +19,9 @@ export const getSeasons = async (req, res) => {
export const getCurrentSeason = async (req, res) => {
try {
const { authcode: token } = req.headers;
devLog('[getCurrentSeason] - Getting current season');
const user = await getUserByToken(token);
const season = await SeasonService.getOrCreateCurrentSeason();
devLog('[getCurrentSeason] - Current season:', season.season);
res.status(200).json(season);
} catch (error) {
@@ -39,7 +35,6 @@ export const createSeason = async (req, res) => {
const { authcode: token } = req.headers;
const { season } = req.body;
devLog('[createSeason] - Creating season:', season);
const user = await getUserByToken(token);
if (!season) {
@@ -53,7 +48,6 @@ export const createSeason = async (req, res) => {
}
const newSeason = await SeasonService.createSeason(season);
devLog('[createSeason] - Season created with ID:', newSeason.id);
res.status(201).json(newSeason);
} catch (error) {
@@ -71,7 +65,6 @@ export const getSeason = async (req, res) => {
const { authcode: token } = req.headers;
const { seasonid: seasonId } = req.params;
devLog('[getSeason] - Getting season:', seasonId);
const user = await getUserByToken(token);
const season = await SeasonService.getSeasonById(seasonId);
@@ -91,7 +84,6 @@ export const deleteSeason = async (req, res) => {
const { authcode: token } = req.headers;
const { seasonid: seasonId } = req.params;
devLog('[deleteSeason] - Deleting season:', seasonId);
const user = await getUserByToken(token);
const success = await SeasonService.deleteSeason(seasonId);

9
backend/controllers/teamController.js
View File

@@ -8,12 +8,10 @@ export const getTeams = async (req, res) => {
const { clubid: clubId } = req.params;
const { seasonid: seasonId } = req.query;
devLog('[getTeams] - Getting teams for club:', clubId, 'season:', seasonId);
const user = await getUserByToken(token);
// Check if user has access to this club
const teams = await TeamService.getAllTeamsByClub(clubId, seasonId);
devLog('[getTeams] - Found teams:', teams.length);
res.status(200).json(teams);
} catch (error) {
@@ -27,7 +25,6 @@ export const getTeam = async (req, res) => {
const { authcode: token } = req.headers;
const { teamid: teamId } = req.params;
devLog('[getTeam] - Getting team:', teamId);
const user = await getUserByToken(token);
const team = await TeamService.getTeamById(teamId);
@@ -48,7 +45,6 @@ export const createTeam = async (req, res) => {
const { clubid: clubId } = req.params;
const { name, leagueId, seasonId } = req.body;
devLog('[createTeam] - Creating team:', { name, clubId, leagueId, seasonId });
const user = await getUserByToken(token);
if (!name) {
@@ -63,7 +59,6 @@ export const createTeam = async (req, res) => {
};
const newTeam = await TeamService.createTeam(teamData);
devLog('[createTeam] - Team created with ID:', newTeam.id);
res.status(201).json(newTeam);
} catch (error) {
@@ -78,7 +73,6 @@ export const updateTeam = async (req, res) => {
const { teamid: teamId } = req.params;
const { name, leagueId, seasonId } = req.body;
devLog('[updateTeam] - Updating team:', teamId, { name, leagueId, seasonId });
const user = await getUserByToken(token);
const updateData = {};
@@ -104,7 +98,6 @@ export const deleteTeam = async (req, res) => {
const { authcode: token } = req.headers;
const { teamid: teamId } = req.params;
devLog('[deleteTeam] - Deleting team:', teamId);
const user = await getUserByToken(token);
const success = await TeamService.deleteTeam(teamId);
@@ -125,11 +118,9 @@ export const getLeagues = async (req, res) => {
const { clubid: clubId } = req.params;
const { seasonid: seasonId } = req.query;
devLog('[getLeagues] - Getting leagues for club:', clubId, 'season:', seasonId);
const user = await getUserByToken(token);
const leagues = await TeamService.getLeaguesByClub(clubId, seasonId);
devLog('[getLeagues] - Found leagues:', leagues.length);
res.status(200).json(leagues);
} catch (error) {

18
backend/controllers/teamDocumentController.js
View File

@@ -43,7 +43,6 @@ export const uploadDocument = async (req, res) => {
const { clubteamid: clubTeamId } = req.params;
const { documentType } = req.body;
devLog('[uploadDocument] - Uploading document for club team:', clubTeamId, 'type:', documentType);
const user = await getUserByToken(token);
if (!req.file) {
@@ -56,7 +55,6 @@ export const uploadDocument = async (req, res) => {
const document = await TeamDocumentService.uploadDocument(req.file, clubTeamId, documentType);
devLog('[uploadDocument] - Document uploaded successfully:', document.id);
res.status(201).json(document);
} catch (error) {
console.error('[uploadDocument] - Error:', error);
@@ -84,11 +82,9 @@ export const getDocuments = async (req, res) => {
const { authcode: token } = req.headers;
const { clubteamid: clubTeamId } = req.params;
devLog('[getDocuments] - Getting documents for club team:', clubTeamId);
const user = await getUserByToken(token);
const documents = await TeamDocumentService.getDocumentsByClubTeam(clubTeamId);
devLog('[getDocuments] - Found documents:', documents.length);
res.status(200).json(documents);
} catch (error) {
@@ -102,7 +98,6 @@ export const getDocument = async (req, res) => {
const { authcode: token } = req.headers;
const { documentid: documentId } = req.params;
devLog('[getDocument] - Getting document:', documentId);
const user = await getUserByToken(token);
const document = await TeamDocumentService.getDocumentById(documentId);
@@ -122,7 +117,6 @@ export const downloadDocument = async (req, res) => {
const { authcode: token } = req.headers;
const { documentid: documentId } = req.params;
devLog('[downloadDocument] - Downloading document:', documentId);
const user = await getUserByToken(token);
const document = await TeamDocumentService.getDocumentById(documentId);
@@ -158,7 +152,6 @@ export const deleteDocument = async (req, res) => {
const { authcode: token } = req.headers;
const { documentid: documentId } = req.params;
devLog('[deleteDocument] - Deleting document:', documentId);
const user = await getUserByToken(token);
const success = await TeamDocumentService.deleteDocument(documentId);
@@ -179,7 +172,6 @@ export const parsePDF = async (req, res) => {
const { documentid: documentId } = req.params;
const { leagueid: leagueId } = req.query;
devLog('[parsePDF] - Parsing PDF document:', documentId, 'league:', leagueId);
const user = await getUserByToken(token);
if (!leagueId) {
@@ -203,19 +195,9 @@ export const parsePDF = async (req, res) => {
// Speichere Matches in Datenbank
const saveResult = await PDFParserService.saveMatchesToDatabase(parseResult.matches, parseInt(leagueId));
devLog('[parsePDF] - PDF parsed successfully:', {
matchesFound: parseResult.matches.length,
created: saveResult.created,
updated: saveResult.updated,
errors: saveResult.errors.length
});
res.status(200).json({
message: "PDF parsed successfully",
parseResult: {
matchesFound: parseResult.matches.length,
errors: parseResult.errors,
metadata: parseResult.metadata,
debugInfo: parseResult.debugInfo,
allLines: parseResult.allLines,
rawText: parseResult.rawText

12
backend/services/clubTeamService.js
View File

@@ -14,7 +14,6 @@ class ClubTeamService {
*/
static async getAllClubTeamsByClub(clubId, seasonId = null) {
try {
devLog('[ClubTeamService.getAllClubTeamsByClub] - Getting club teams for club:', clubId, 'season:', seasonId);
// Wenn keine Saison angegeben, verwende die aktuelle
if (!seasonId) {
@@ -56,7 +55,6 @@ class ClubTeamService {
enrichedClubTeams.push(enrichedTeam);
}
devLog('[ClubTeamService.getAllClubTeamsByClub] - Found club teams:', enrichedClubTeams.length);
return enrichedClubTeams;
} catch (error) {
console.error('[ClubTeamService.getAllClubTeamsByClub] - Error:', error);
@@ -71,7 +69,6 @@ class ClubTeamService {
*/
static async getClubTeamById(clubTeamId) {
try {
devLog('[ClubTeamService.getClubTeamById] - Getting club team:', clubTeamId);
const clubTeam = await ClubTeam.findByPk(clubTeamId, {
include: [
{
@@ -86,7 +83,6 @@ class ClubTeamService {
}
]
});
devLog('[ClubTeamService.getClubTeamById] - Found club team:', clubTeam ? 'yes' : 'no');
return clubTeam;
} catch (error) {
console.error('[ClubTeamService.getClubTeamById] - Error:', error);
@@ -102,7 +98,6 @@ class ClubTeamService {
*/
static async createClubTeam(clubTeamData) {
try {
devLog('[ClubTeamService.createClubTeam] - Creating club team:', clubTeamData);
// Wenn keine Saison angegeben, verwende die aktuelle
if (!clubTeamData.seasonId) {
@@ -111,7 +106,6 @@ class ClubTeamService {
}
const clubTeam = await ClubTeam.create(clubTeamData);
devLog('[ClubTeamService.createClubTeam] - Club team created with ID:', clubTeam.id);
return clubTeam;
} catch (error) {
console.error('[ClubTeamService.createClubTeam] - Error:', error);
@@ -127,11 +121,9 @@ class ClubTeamService {
*/
static async updateClubTeam(clubTeamId, updateData) {
try {
devLog('[ClubTeamService.updateClubTeam] - Updating club team:', clubTeamId, updateData);
const [updatedRowsCount] = await ClubTeam.update(updateData, {
where: { id: clubTeamId }
});
devLog('[ClubTeamService.updateClubTeam] - Updated rows:', updatedRowsCount);
return updatedRowsCount > 0;
} catch (error) {
console.error('[ClubTeamService.updateClubTeam] - Error:', error);
@@ -146,11 +138,9 @@ class ClubTeamService {
*/
static async deleteClubTeam(clubTeamId) {
try {
devLog('[ClubTeamService.deleteClubTeam] - Deleting club team:', clubTeamId);
const deletedRows = await ClubTeam.destroy({
where: { id: clubTeamId }
});
devLog('[ClubTeamService.deleteClubTeam] - Deleted rows:', deletedRows);
return deletedRows > 0;
} catch (error) {
console.error('[ClubTeamService.deleteClubTeam] - Error:', error);
@@ -167,7 +157,6 @@ class ClubTeamService {
*/
static async getLeaguesByClub(clubId, seasonId = null) {
try {
devLog('[ClubTeamService.getLeaguesByClub] - Getting leagues for club:', clubId, 'season:', seasonId);
// Wenn keine Saison angegeben, verwende die aktuelle
if (!seasonId) {
@@ -180,7 +169,6 @@ class ClubTeamService {
attributes: ['id', 'name', 'seasonId'],
order: [['name', 'ASC']]
});
devLog('[ClubTeamService.getLeaguesByClub] - Found leagues:', leagues.length);
return leagues;
} catch (error) {
console.error('[ClubTeamService.getLeaguesByClub] - Error:', error);

30
backend/services/diaryDateActivityService.js
View File

@@ -10,9 +10,7 @@ import { devLog } from '../utils/logger.js';
class DiaryDateActivityService {
async createActivity(userToken, clubId, data) {
devLog('[DiaryDateActivityService::createActivity] - check user access');
await checkAccess(userToken, clubId);
devLog('[DiaryDateActivityService::createActivity] - add: ', data);
const { activity, ...restData } = data;
// Versuche, die PredefinedActivity robust zu finden:
// 1) per übergebener ID
@@ -60,23 +58,18 @@ class DiaryDateActivityService {
});
const newOrderId = maxOrderId !== null ? maxOrderId + 1 : 1;
restData.orderId = newOrderId;
devLog('[DiaryDateActivityService::createActivity] - create diary date activity');
return await DiaryDateActivity.create(restData);
}
async updateActivity(userToken, clubId, id, data) {
devLog('[DiaryDateActivityService::updateActivity] - check user access');
await checkAccess(userToken, clubId);
devLog('[DiaryDateActivityService::updateActivity] - load activity', id);
const activity = await DiaryDateActivity.findByPk(id);
if (!activity) {
devLog('[DiaryDateActivityService::updateActivity] - activity not found');
throw new Error('Activity not found');
}
// Wenn customActivityName gesendet wird, müssen wir die PredefinedActivity behandeln
if (data.customActivityName) {
devLog('[DiaryDateActivityService::updateActivity] - handling customActivityName:', data.customActivityName);
// Suche nach einer existierenden PredefinedActivity mit diesem Namen
let predefinedActivity = await PredefinedActivity.findOne({
@@ -85,7 +78,6 @@ class DiaryDateActivityService {
if (!predefinedActivity) {
// Erstelle eine neue PredefinedActivity
devLog('[DiaryDateActivityService::updateActivity] - creating new PredefinedActivity');
predefinedActivity = await PredefinedActivity.create({
name: data.customActivityName,
description: data.description || '',
@@ -100,7 +92,6 @@ class DiaryDateActivityService {
delete data.customActivityName;
}
devLog('[DiaryDateActivityService::updateActivity] - update activity', clubId, id, data, JSON.stringify(data));
return await activity.update(data);
}
@@ -114,22 +105,14 @@ class DiaryDateActivityService {
}
async updateActivityOrder(userToken, clubId, id, newOrderId) {
devLog(`[DiaryDateActivityService::updateActivityOrder] - Start update for activity id: ${id}`);
devLog(`[DiaryDateActivityService::updateActivityOrder] - User token: ${userToken}, Club id: ${clubId}, New order id: ${newOrderId}`);
devLog('[DiaryDateActivityService::updateActivityOrder] - Checking user access');
await checkAccess(userToken, clubId);
devLog('[DiaryDateActivityService::updateActivityOrder] - User access confirmed');
devLog(`[DiaryDateActivityService::updateActivityOrder] - Finding activity with id: ${id}`);
const activity = await DiaryDateActivity.findByPk(id);
if (!activity) {
console.error('[DiaryDateActivityService::updateActivityOrder] - Activity not found, throwing error');
throw new Error('Activity not found');
}
devLog('[DiaryDateActivityService::updateActivityOrder] - Activity found:', activity);
const currentOrderId = activity.orderId;
devLog(`[DiaryDateActivityService::updateActivityOrder] - Current order id: ${currentOrderId}`);
if (newOrderId < currentOrderId) {
devLog(`[DiaryDateActivityService::updateActivityOrder] - Shifting items down. Moving activities with orderId between ${newOrderId} and ${currentOrderId - 1}`);
await DiaryDateActivity.increment(
{ orderId: 1 },
{
@@ -139,9 +122,7 @@ class DiaryDateActivityService {
},
}
);
devLog(`[DiaryDateActivityService::updateActivityOrder] - Items shifted down`);
} else if (newOrderId > currentOrderId) {
devLog(`[DiaryDateActivityService::updateActivityOrder] - Shifting items up. Moving activities with orderId between ${currentOrderId + 1} and ${newOrderId}`);
await DiaryDateActivity.decrement(
{ orderId: 1 },
{
@@ -151,16 +132,10 @@ class DiaryDateActivityService {
},
}
);
devLog(`[DiaryDateActivityService::updateActivityOrder] - Items shifted up`);
} else {
devLog('[DiaryDateActivityService::updateActivityOrder] - New order id is the same as the current order id. No shift required.');
}
devLog(`[DiaryDateActivityService::updateActivityOrder] - Setting new order id for activity id: ${id}`);
activity.orderId = newOrderId;
devLog('[DiaryDateActivityService::updateActivityOrder] - Saving activity with new order id');
const savedActivity = await activity.save();
devLog('[DiaryDateActivityService::updateActivityOrder] - Activity saved:', savedActivity);
devLog(`[DiaryDateActivityService::updateActivityOrder] - Finished update for activity id: ${id}`);
return savedActivity;
}
@@ -257,9 +232,7 @@ class DiaryDateActivityService {
}
async addGroupActivity(userToken, clubId, diaryDateId, groupId, activity) {
devLog('[DiaryDateActivityService::addGroupActivity] Check user access');
await checkAccess(userToken, clubId);
devLog('[DiaryDateActivityService::addGroupActivity] Check diary date');
const diaryDateActivity = await DiaryDateActivity.findOne({
where: {
diaryDateId,
@@ -272,19 +245,16 @@ class DiaryDateActivityService {
console.error('[DiaryDateActivityService::addGroupActivity] Activity not found');
throw new Error('Activity not found');
}
devLog('[DiaryDateActivityService::addGroupActivity] Check group');
const group = await Group.findByPk(groupId);
if (!group || group.diaryDateId !== diaryDateActivity.diaryDateId) {
console.error('[DiaryDateActivityService::addGroupActivity] Group and date don\'t fit');
throw new Error('Group isn\'t related to date');
}
devLog('[DiaryDateActivityService::addGroupActivity] Get predefined activity');
const [predefinedActivity, created] = await PredefinedActivity.findOrCreate({
where: {
name: activity
}
});
devLog('[DiaryDateActivityService::addGroupActivity] Add group activity');
devLog(predefinedActivity);
const activityData = {
diaryDateActivity: diaryDateActivity.id,

23
backend/services/diaryService.js
View File

@@ -10,14 +10,11 @@ import HttpError from '../exceptions/HttpError.js';
import { devLog } from '../utils/logger.js';
class DiaryService {
async getDatesForClub(userToken, clubId) {
devLog('[DiaryService::getDatesForClub] - Check user access');
await checkAccess(userToken, clubId);
devLog('[DiaryService::getDatesForClub] - Validate club existence');
const club = await Club.findByPk(clubId);
if (!club) {
throw new HttpError('Club not found', 404);
}
devLog('[DiaryService::getDatesForClub] - Load diary dates');
const dates = await DiaryDate.findAll({
where: { clubId },
include: [
@@ -30,14 +27,11 @@ class DiaryService {
}
async createDateForClub(userToken, clubId, date, trainingStart, trainingEnd) {
devLog('[DiaryService::createDateForClub] - Check user access');
await checkAccess(userToken, clubId);
devLog('[DiaryService::createDateForClub] - Validate club existence');
const club = await Club.findByPk(clubId);
if (!club) {
throw new HttpError('Club not found', 404);
}
devLog('[DiaryService::createDateForClub] - Validate date');
const parsedDate = new Date(date);
if (isNaN(parsedDate.getTime())) {
throw new HttpError('Invalid date format', 400);
@@ -45,7 +39,6 @@ class DiaryService {
if (trainingStart && trainingEnd && trainingStart >= trainingEnd) {
throw new HttpError('Training start time must be before training end time', 400);
}
devLog('[DiaryService::createDateForClub] - Create new diary date');
const newDate = await DiaryDate.create({
date: parsedDate,
clubId,
@@ -57,9 +50,7 @@ class DiaryService {
}
async updateTrainingTimes(userToken, clubId, dateId, trainingStart, trainingEnd) {
devLog('[DiaryService::updateTrainingTimes] - Check user access');
await checkAccess(userToken, clubId);
devLog('[DiaryService::updateTrainingTimes] - Validate date');
const diaryDate = await DiaryDate.findOne({ where: { clubId, id: dateId } });
if (!diaryDate) {
throw new HttpError('Diary entry not found', 404);
@@ -67,7 +58,6 @@ class DiaryService {
if (trainingStart && trainingEnd && trainingStart >= trainingEnd) {
throw new HttpError('Training start time must be before training end time', 400);
}
devLog('[DiaryService::updateTrainingTimes] - Update training times');
diaryDate.trainingStart = trainingStart || null;
diaryDate.trainingEnd = trainingEnd || null;
await diaryDate.save();
@@ -75,14 +65,12 @@ class DiaryService {
}
async addNoteToDate(userToken, diaryDateId, content) {
devLog('[DiaryService::addNoteToDate] - Add note');
await checkAccess(userToken, diaryDateId);
await DiaryNote.create({ diaryDateId, content });
return await DiaryNote.findAll({ where: { diaryDateId }, order: [['createdAt', 'DESC']] });
}
async deleteNoteFromDate(userToken, noteId) {
devLog('[DiaryService::deleteNoteFromDate] - Delete note');
const note = await DiaryNote.findByPk(noteId);
if (!note) {
throw new HttpError('Note not found', 404);
@@ -93,7 +81,6 @@ class DiaryService {
}
async addTagToDate(userToken, diaryDateId, tagName) {
devLog('[DiaryService::addTagToDate] - Add tag');
await checkAccess(userToken, diaryDateId);
let tag = await DiaryTag.findOne({ where: { name: tagName } });
if (!tag) {
@@ -106,29 +93,24 @@ class DiaryService {
async addTagToDiaryDate(userToken, clubId, diaryDateId, tagId) {
checkAccess(userToken, clubId);
devLog(`[DiaryService::addTagToDiaryDate] - diaryDateId: ${diaryDateId}, tagId: ${tagId}`);
const diaryDate = await DiaryDate.findByPk(diaryDateId);
if (!diaryDate) {
throw new HttpError('DiaryDate not found', 404);
}
devLog('[DiaryService::addTagToDiaryDate] - Add tag to diary date');
const existingEntry = await DiaryDateTag.findOne({
where: { diaryDateId, tagId }
});
if (existingEntry) {
return;
}
devLog('[DiaryService::addTagToDiaryDate] - Tag not found, creating new entry');
const tag = await DiaryTag.findByPk(tagId);
if (!tag) {
throw new HttpError('Tag not found', 404);
}
devLog('[DiaryService::addTagToDiaryDate] - Add tag to diary date');
await DiaryDateTag.create({
diaryDateId,
tagId
});
devLog('[DiaryService::addTagToDiaryDate] - Get tags');
const tags = await DiaryDateTag.findAll({ where: {
diaryDateId: diaryDateId },
include: {
@@ -141,7 +123,6 @@ class DiaryService {
}
async getDiaryNotesForDateAndMember(diaryDateId, memberId) {
devLog('[DiaryService::getDiaryNotesForDateAndMember] - Fetching notes');
return await DiaryNote.findAll({
where: { diaryDateId, memberId },
order: [['createdAt', 'DESC']]
@@ -154,19 +135,15 @@ class DiaryService {
}
async removeDateForClub(userToken, clubId, dateId) {
devLog('[DiaryService::removeDateForClub] - Check user access');
await checkAccess(userToken, clubId);
devLog('[DiaryService::removeDateForClub] - Validate date');
const diaryDate = await DiaryDate.findOne({ where: { id: dateId, clubId } });
if (!diaryDate) {
throw new HttpError('Diary entry not found', 404);
}
devLog('[DiaryService::removeDateForClub] - Check for activities');
const activityCount = await DiaryDateActivity.count({ where: { diaryDateId: dateId } });
if (activityCount > 0) {
throw new HttpError('Cannot delete date with activities', 409);
}
devLog('[DiaryService::removeDateForClub] - Delete diary date');
await diaryDate.destroy();
return { ok: true };
}

10
backend/services/leagueService.js
View File

@@ -6,7 +6,6 @@ import { devLog } from '../utils/logger.js';
class LeagueService {
static async getAllLeaguesByClub(clubId, seasonId = null) {
try {
devLog('[LeagueService.getAllLeaguesByClub] - Getting leagues for club:', clubId, 'season:', seasonId);
// Wenn keine Saison angegeben, verwende die aktuelle
if (!seasonId) {
@@ -25,7 +24,6 @@ class LeagueService {
],
order: [['name', 'ASC']]
});
devLog('[LeagueService.getAllLeaguesByClub] - Found leagues:', leagues.length);
return leagues;
} catch (error) {
console.error('[LeagueService.getAllLeaguesByClub] - Error:', error);
@@ -35,7 +33,6 @@ class LeagueService {
static async getLeagueById(leagueId) {
try {
devLog('[LeagueService.getLeagueById] - Getting league:', leagueId);
const league = await League.findByPk(leagueId, {
include: [
{
@@ -45,7 +42,6 @@ class LeagueService {
}
]
});
devLog('[LeagueService.getLeagueById] - Found league:', league ? 'yes' : 'no');
return league;
} catch (error) {
console.error('[LeagueService.getLeagueById] - Error:', error);
@@ -55,7 +51,6 @@ class LeagueService {
static async createLeague(leagueData) {
try {
devLog('[LeagueService.createLeague] - Creating league:', leagueData);
// Wenn keine Saison angegeben, verwende die aktuelle
if (!leagueData.seasonId) {
@@ -64,7 +59,6 @@ class LeagueService {
}
const league = await League.create(leagueData);
devLog('[LeagueService.createLeague] - League created with ID:', league.id);
return league;
} catch (error) {
console.error('[LeagueService.createLeague] - Error:', error);
@@ -74,11 +68,9 @@ class LeagueService {
static async updateLeague(leagueId, updateData) {
try {
devLog('[LeagueService.updateLeague] - Updating league:', leagueId, updateData);
const [updatedRowsCount] = await League.update(updateData, {
where: { id: leagueId }
});
devLog('[LeagueService.updateLeague] - Updated rows:', updatedRowsCount);
return updatedRowsCount > 0;
} catch (error) {
console.error('[LeagueService.updateLeague] - Error:', error);
@@ -88,11 +80,9 @@ class LeagueService {
static async deleteLeague(leagueId) {
try {
devLog('[LeagueService.deleteLeague] - Deleting league:', leagueId);
const deletedRowsCount = await League.destroy({
where: { id: leagueId }
});
devLog('[LeagueService.deleteLeague] - Deleted rows:', deletedRowsCount);
return deletedRowsCount > 0;
} catch (error) {
console.error('[LeagueService.deleteLeague] - Error:', error);

44
backend/services/memberService.js
View File

@@ -9,11 +9,8 @@ import sharp from 'sharp';
import { devLog } from '../utils/logger.js';
class MemberService {
async getApprovalRequests(userToken, clubId) {
devLog('[MemberService::getApprovalRequest] - Check user access');
await checkAccess(userToken, clubId);
devLog('[MemberService::getApprovalRequest] - Load user');
const user = await getUserByToken(userToken);
devLog('[MemberService::getApprovalRequest] - Load userclub');
return await UserClub.findAll({
where: {
clubId: clubId,
@@ -24,9 +21,7 @@ class MemberService {
}
async getClubMembers(userToken, clubId, showAll) {
devLog('[getClubMembers] - Check access');
await checkAccess(userToken, clubId);
devLog('[getClubMembers] - Find members');
const where = {
clubId: clubId
};
@@ -45,7 +40,6 @@ class MemberService {
});
})
.then(membersWithImageStatus => {
devLog('[getClubMembers] - return members');
return membersWithImageStatus;
})
.catch(error => {
@@ -57,15 +51,11 @@ class MemberService {
async setClubMember(userToken, clubId, memberId, firstName, lastName, street, city, birthdate, phone, email, active = true, testMembership = false,
picsInInternetAllowed = false, gender = 'unknown', ttr = null, qttr = null) {
try {
devLog('[setClubMembers] - Check access');
await checkAccess(userToken, clubId);
devLog('[setClubMembers] - set default member');
let member = null;
devLog('[setClubMembers] - load member if possible');
if (memberId) {
member = await Member.findOne({ where: { id: memberId } });
}
devLog('[setClubMembers] - set member');
if (member) {
member.firstName = firstName;
member.lastName = lastName;
@@ -99,7 +89,6 @@ class MemberService {
qttr: qttr,
});
}
devLog('[setClubMembers] - return response');
return {
status: 200,
response: { result: "success" },
@@ -153,34 +142,18 @@ class MemberService {
}
async updateRatingsFromMyTischtennis(userToken, clubId) {
devLog('[updateRatingsFromMyTischtennis] - Check access');
await checkAccess(userToken, clubId);
const user = await getUserByToken(userToken);
devLog('[updateRatingsFromMyTischtennis] - User:', user.id);
const myTischtennisService = (await import('./myTischtennisService.js')).default;
const myTischtennisClient = (await import('../clients/myTischtennisClient.js')).default;
try {
// 1. myTischtennis-Session abrufen
devLog('[updateRatingsFromMyTischtennis] - Get session for user', user.id);
const session = await myTischtennisService.getSession(user.id);
devLog('[updateRatingsFromMyTischtennis] - Session retrieved:', {
hasAccessToken: !!session.accessToken,
hasCookie: !!session.cookie,
expiresAt: session.expiresAt
});
const account = await myTischtennisService.getAccount(user.id);
devLog('[updateRatingsFromMyTischtennis] - Account data:', {
id: account?.id,
email: account?.email,
clubId: account?.clubId,
clubName: account?.clubName,
fedNickname: account?.fedNickname,
hasSession: !!(account?.accessToken)
});
if (!account) {
console.error('[updateRatingsFromMyTischtennis] - No account found!');
@@ -217,24 +190,12 @@ class MemberService {
}
// 2. Rangliste vom Verein abrufen
devLog('[updateRatingsFromMyTischtennis] - Get club rankings', {
clubId: account.clubId,
fedNickname: account.fedNickname,
hasCookie: !!session.cookie
});
const rankings = await myTischtennisClient.getClubRankings(
session.cookie,
account.clubId,
account.fedNickname
);
devLog('[updateRatingsFromMyTischtennis] - Rankings result:', {
success: rankings.success,
entriesCount: rankings.entries?.length || 0,
error: rankings.error
});
if (!rankings.success) {
return {
status: 500,
@@ -252,9 +213,7 @@ class MemberService {
}
// 3. Alle Mitglieder des Clubs laden
devLog('[updateRatingsFromMyTischtennis] - Load club members for clubId:', clubId);
const members = await Member.findAll({ where: { clubId } });
devLog('[updateRatingsFromMyTischtennis] - Found members:', members.length);
let updated = 0;
const errors = [];
@@ -285,7 +244,6 @@ class MemberService {
oldTtr: oldTtr,
newTtr: rankingEntry.fedRank
});
devLog(`[updateRatingsFromMyTischtennis] - Updated ${firstName} ${lastName}: TTR ${oldTtr} → ${rankingEntry.fedRank}`);
} catch (error) {
console.error(`[updateRatingsFromMyTischtennis] - Error updating ${firstName} ${lastName}:`, error);
errors.push({
@@ -295,11 +253,9 @@ class MemberService {
}
} else {
notFound.push(`${firstName} ${lastName}`);
devLog(`[updateRatingsFromMyTischtennis] - Not found in rankings: ${firstName} ${lastName}`);
}
}
devLog('[updateRatingsFromMyTischtennis] - Update complete');
devLog(`Updated: ${updated}, Not found: ${notFound.length}, Errors: ${errors.length}`);
let message = `${updated} Mitglied(er) aktualisiert.`;

16
backend/services/myTischtennisService.js
View File

@@ -68,20 +68,12 @@ class MyTischtennisService {
account.userData = loginResult.user;
// Hole Club-ID und Federation
devLog('[myTischtennisService] - Getting user profile...');
const profileResult = await myTischtennisClient.getUserProfile(loginResult.cookie);
devLog('[myTischtennisService] - Profile result:', {
success: profileResult.success,
clubId: profileResult.clubId,
clubName: profileResult.clubName,
fedNickname: profileResult.fedNickname
});
if (profileResult.success) {
account.clubId = profileResult.clubId;
account.clubName = profileResult.clubName;
account.fedNickname = profileResult.fedNickname;
devLog('[myTischtennisService] - Updated account with club data');
} else {
console.error('[myTischtennisService] - Failed to get profile:', profileResult.error);
}
@@ -177,20 +169,12 @@ class MyTischtennisService {
account.userData = loginResult.user;
// Hole Club-ID und Federation
devLog('[myTischtennisService] - Getting user profile...');
const profileResult = await myTischtennisClient.getUserProfile(loginResult.cookie);
devLog('[myTischtennisService] - Profile result:', {
success: profileResult.success,
clubId: profileResult.clubId,
clubName: profileResult.clubName,
fedNickname: profileResult.fedNickname
});
if (profileResult.success) {
account.clubId = profileResult.clubId;
account.clubName = profileResult.clubName;
account.fedNickname = profileResult.fedNickname;
devLog('[myTischtennisService] - Updated account with club data');
} else {
console.error('[myTischtennisService] - Failed to get profile:', profileResult.error);
}

54
backend/services/pdfParserService.js
View File

@@ -24,7 +24,6 @@ class PDFParserService {
*/
static async parsePDF(filePath, clubId) {
try {
devLog('[PDFParserService.parsePDF] - Parsing PDF:', filePath);
if (!fs.existsSync(filePath)) {
throw new Error('PDF-Datei nicht gefunden');
@@ -39,17 +38,14 @@ class PDFParserService {
const pdfBuffer = fs.readFileSync(filePath);
const pdfData = await pdfParse(pdfBuffer);
fileContent = pdfData.text;
devLog('[PDFParserService.parsePDF] - PDF parsed, text length:', fileContent.length);
} else {
// Fallback für TXT-Dateien (für Tests)
fileContent = fs.readFileSync(filePath, 'utf8');
devLog('[PDFParserService.parsePDF] - Text file loaded, text length:', fileContent.length);
}
// Parse den Text nach Spiel-Daten
const parsedData = this.extractMatchData(fileContent, clubId);
devLog('[PDFParserService.parsePDF] - Extracted matches:', parsedData.matches.length);
return parsedData;
} catch (error) {
@@ -78,7 +74,6 @@ class PDFParserService {
const lines = text.split('\n').map(line => line.trim()).filter(line => line.length > 0);
metadata.totalLines = lines.length;
devLog('[PDFParserService.extractMatchData] - Processing lines:', lines.length);
// Verschiedene Parsing-Strategien je nach PDF-Format
const strategies = [
@@ -87,22 +82,17 @@ class PDFParserService {
{ name: 'List Format', fn: this.parseListFormat }
];
devLog('[PDFParserService.extractMatchData] - Trying parsing strategies...');
for (const strategy of strategies) {
try {
devLog(`[PDFParserService.extractMatchData] - Trying ${strategy.name}...`);
const result = strategy.fn(lines, clubId);
devLog(`[PDFParserService.extractMatchData] - ${strategy.name} found ${result.matches.length} matches`);
if (result.matches.length > 0) {
matches.push(...result.matches);
metadata.parsedMatches += result.matches.length;
devLog(`[PDFParserService.extractMatchData] - Using ${strategy.name} strategy`);
break; // Erste erfolgreiche Strategie verwenden
}
} catch (strategyError) {
devLog(`[PDFParserService.extractMatchData] - ${strategy.name} failed:`, strategyError.message);
errors.push(`Strategy ${strategy.name} failed: ${strategyError.message}`);
}
}
@@ -137,7 +127,6 @@ class PDFParserService {
static parseStandardFormat(lines, clubId) {
const matches = [];
devLog('[PDFParserService.parseStandardFormat] - Starting standard format parsing...');
for (let i = 0; i < lines.length; i++) {
const line = lines[i];
@@ -145,7 +134,6 @@ class PDFParserService {
// Suche nach Datum-Pattern (dd.mm.yyyy oder dd/mm/yyyy)
const dateMatch = line.match(/(\d{1,2})[./](\d{1,2})[./](\d{4})/);
if (dateMatch) {
devLog(`[PDFParserService.parseStandardFormat] - Found date in line ${i + 1}: "${line}"`);
// Debug: Zeige die gesamte Zeile mit sichtbaren Whitespaces
const debugLine = line.replace(/\s/g, (match) => {
@@ -155,7 +143,6 @@ class PDFParserService {
if (match === '\r') return '⏎'; // Carriage Return
return `[${match.charCodeAt(0)}]`; // Zeichencode für andere Whitespaces
});
devLog(`[PDFParserService.parseStandardFormat] - Full line with visible whitespaces: "${debugLine}"`);
try {
const [, day, month, year] = dateMatch;
@@ -168,19 +155,15 @@ class PDFParserService {
time = `${timeMatch[4].padStart(2, '0')}:${timeMatch[5]}`;
}
devLog(`[PDFParserService.parseStandardFormat] - Parsed date: ${date.toISOString().split('T')[0]}, time: ${time}`);
// Entferne Datum und Zeit vom Anfang der Zeile
const cleanLine = line.replace(/^[A-Za-z]{2}\.(\d{1,2})[./](\d{1,2})[./](\d{4})(\d{1,2}):(\d{2})\s*/, '');
devLog(`[PDFParserService.parseStandardFormat] - Clean line after date/time removal: "${cleanLine}"`);
// Entferne Nummerierung am Anfang (z.B. "(1)")
const cleanLine2 = cleanLine.replace(/^\(\d+\)/, '');
devLog(`[PDFParserService.parseStandardFormat] - Clean line after numbering removal: "${cleanLine2}"`);
// Entferne alle Inhalte in Klammern (z.B. "(J11)")
const cleanLine3 = cleanLine2.replace(/\([^)]*\)/g, '');
devLog(`[PDFParserService.parseStandardFormat] - Clean line after removing brackets: "${cleanLine3}"`);
// Suche nach Code (12 Zeichen) oder PIN (4 Ziffern) am Ende
const codeMatch = cleanLine3.match(/([A-Z0-9]{12})$/);
@@ -195,7 +178,6 @@ class PDFParserService {
// Code gefunden (12 Zeichen)
code = codeMatch[1];
teamsPart = cleanLine3.substring(0, cleanLine3.length - code.length).trim();
devLog(`[PDFParserService.parseStandardFormat] - Found code: "${code}"`);
} else if (pinMatch) {
// PIN gefunden (4 Ziffern)
const pin = pinMatch[1];
@@ -211,17 +193,14 @@ class PDFParserService {
if (pinIndex === teamsPartIndex + teamsPart.length) {
// PIN steht direkt nach den Teams -> Heimmannschaft
homePin = pin;
devLog(`[PDFParserService.parseStandardFormat] - Found PIN: "${pin}" -> Home team (at end)`);
} else {
// PIN steht zwischen den Teams -> Gastmannschaft
guestPin = pin;
devLog(`[PDFParserService.parseStandardFormat] - Found PIN: "${pin}" -> Guest team (between teams)`);
}
}
if (code || pinMatch) {
devLog(`[PDFParserService.parseStandardFormat] - Teams part: "${teamsPart}"`);
// Debug: Zeige Whitespaces als lesbare Zeichen
const debugTeamsPart = teamsPart.replace(/\s/g, (match) => {
@@ -229,13 +208,11 @@ class PDFParserService {
if (match === '\t') return '→'; // Pfeil für Tab
return `[${match.charCodeAt(0)}]`; // Zeichencode für andere Whitespaces
});
devLog(`[PDFParserService.parseStandardFormat] - Teams part with visible whitespaces: "${debugTeamsPart}"`);
// Neue Strategie: Teile die Zeile durch mehrere Leerzeichen (wie in der Tabelle)
// Die Struktur ist: Heimmannschaft Gastmannschaft Code
const parts = teamsPart.split(/\s{2,}/); // Mindestens 2 Leerzeichen als Trenner
devLog(`[PDFParserService.parseStandardFormat] - Split by multiple spaces:`, parts);
let homeTeamName = '';
let guestTeamName = '';
@@ -248,7 +225,6 @@ class PDFParserService {
homeTeamName = homeTeamName.replace(/\([^)]*\)/g, '').trim();
guestTeamName = guestTeamName.replace(/\([^)]*\)/g, '').trim();
devLog(`[PDFParserService.parseStandardFormat] - After bracket removal: "${homeTeamName}" vs "${guestTeamName}"`);
// Erkenne römische Ziffern am Ende der Team-Namen
// Römische Ziffern: I, II, III, IV, V, VI, VII, VIII, IX, X, XI, XII, etc.
@@ -260,7 +236,6 @@ class PDFParserService {
const romanNumeral = homeRomanMatch[1];
const baseName = homeTeamName.replace(romanNumeralPattern, '').trim();
homeTeamName = `${baseName} ${romanNumeral}`;
devLog(`[PDFParserService.parseStandardFormat] - Home team roman numeral found: "${romanNumeral}" -> "${homeTeamName}"`);
}
// Prüfe Gastteam auf römische Ziffern
@@ -269,13 +244,10 @@ class PDFParserService {
const romanNumeral = guestRomanMatch[1];
const baseName = guestTeamName.replace(romanNumeralPattern, '').trim();
guestTeamName = `${baseName} ${romanNumeral}`;
devLog(`[PDFParserService.parseStandardFormat] - Guest team roman numeral found: "${romanNumeral}" -> "${guestTeamName}"`);
}
devLog(`[PDFParserService.parseStandardFormat] - Final teams: "${homeTeamName}" vs "${guestTeamName}"`);
} else {
// Fallback: Versuche mit einzelnen Leerzeichen zu trennen
devLog(`[PDFParserService.parseStandardFormat] - Fallback: trying single space split`);
// Strategie 1: Suche nach "Harheimer TC" als Heimteam
if (teamsPart.includes('Harheimer TC')) {
@@ -286,7 +258,6 @@ class PDFParserService {
// Entferne Klammern aus Gastteam
guestTeamName = guestTeamName.replace(/\([^)]*\)/g, '').trim();
devLog(`[PDFParserService.parseStandardFormat] - Fallback Strategy 1: "${homeTeamName}" vs "${guestTeamName}"`);
} else {
// Strategie 2: Suche nach Großbuchstaben am Anfang des zweiten Teams
const teamSplitMatch = teamsPart.match(/^([A-Za-z0-9\s\-\.]+?)\s+([A-Z][A-Za-z0-9\s\-\.]+)$/);
@@ -295,9 +266,7 @@ class PDFParserService {
homeTeamName = teamSplitMatch[1].trim();
guestTeamName = teamSplitMatch[2].trim();
devLog(`[PDFParserService.parseStandardFormat] - Fallback Strategy 2: Split teams: "${homeTeamName}" vs "${guestTeamName}"`);
} else {
devLog(`[PDFParserService.parseStandardFormat] - Could not split teams from: "${teamsPart}"`);
continue;
}
}
@@ -314,7 +283,6 @@ class PDFParserService {
} else if (guestPin) {
debugInfo = `guestPin: "${guestPin}"`;
}
devLog(`[PDFParserService.parseStandardFormat] - Final parsed teams: "${homeTeamName}" vs "${guestTeamName}", ${debugInfo}`);
matches.push({
date: date,
@@ -329,10 +297,8 @@ class PDFParserService {
});
}
} else {
devLog(`[PDFParserService.parseStandardFormat] - Could not find code pattern in: "${cleanLine3}"`);
}
} catch (parseError) {
devLog('[PDFParserService.parseStandardFormat] - Parse error for line:', line, parseError.message);
}
}
}
@@ -396,7 +362,6 @@ class PDFParserService {
});
}
} catch (parseError) {
devLog('[PDFParserService.parseTableFormat] - Parse error for line:', line, parseError.message);
}
}
}
@@ -454,7 +419,6 @@ class PDFParserService {
break; // Erste erfolgreiche Pattern verwenden
}
} catch (parseError) {
devLog('[PDFParserService.parseListFormat] - Parse error for line:', line, parseError.message);
}
}
}
@@ -472,7 +436,6 @@ class PDFParserService {
*/
static async saveMatchesToDatabase(matches, leagueId) {
try {
devLog('[PDFParserService.saveMatchesToDatabase] - Saving matches:', matches.length);
const results = {
created: 0,
@@ -492,10 +455,8 @@ class PDFParserService {
} else if (matchData.guestPin) {
debugInfo = `GuestPin: ${matchData.guestPin}`;
}
devLog(`[PDFParserService.saveMatchesToDatabase] - Processing match: ${matchData.date.toISOString().split('T')[0]} ${matchData.time} - ${matchData.homeTeamName} vs ${matchData.guestTeamName} (${debugInfo})`);
// Lade alle Matches für das Datum und die Liga
console.log('matchData', matchData);
// Konvertiere das Datum zu einem Datum ohne Zeit für den Vergleich
const dateOnly = new Date(matchData.date.getFullYear(), matchData.date.getMonth(), matchData.date.getDate());
@@ -524,10 +485,9 @@ class PDFParserService {
}
]
});
console.log('existingMatches', JSON.parse(JSON.stringify(existingMatches, null, 2)));
const timeFilter = matchData.time ? ` and time ${matchData.time}` : '';
devLog(`[PDFParserService.saveMatchesToDatabase] - Found ${existingMatches.length} existing matches for date ${matchData.date.toISOString().split('T')[0]}${timeFilter} and league ${leagueId}`);
// Debug: Zeige alle gefundenen Matches und lade Teams manuell
for (let i = 0; i < existingMatches.length; i++) {
@@ -537,7 +497,6 @@ class PDFParserService {
const homeTeam = await Team.findByPk(match.homeTeamId);
const guestTeam = await Team.findByPk(match.guestTeamId);
devLog(`[PDFParserService.saveMatchesToDatabase] - Match ${i + 1}: ${homeTeam?.name || 'Unknown'} vs ${guestTeam?.name || 'Unknown'} (${match.time || 'no time'})`);
// Füge die Teams zum Match-Objekt hinzu
match.homeTeam = homeTeam;
@@ -558,7 +517,6 @@ class PDFParserService {
});
if (matchingMatch) {
devLog(`[PDFParserService.saveMatchesToDatabase] - Found matching match: ${matchingMatch.homeTeam.name} vs ${matchingMatch.guestTeam.name}`);
// Update das bestehende Match mit Code und Pins
// Erstelle Update-Objekt nur mit vorhandenen Feldern
@@ -586,7 +544,6 @@ class PDFParserService {
} else if (matchData.guestPin) {
updateInfo = `guestPin: ${matchData.guestPin}`;
}
devLog(`[PDFParserService.saveMatchesToDatabase] - Updated match with ${updateInfo}`);
// Lade das aktualisierte Match neu, um die aktuellen Werte zu zeigen
await matchingMatch.reload();
@@ -594,9 +551,7 @@ class PDFParserService {
if (matchingMatch.code) currentValues.push(`code: ${matchingMatch.code}`);
if (matchingMatch.homePin) currentValues.push(`homePin: ${matchingMatch.homePin}`);
if (matchingMatch.guestPin) currentValues.push(`guestPin: ${matchingMatch.guestPin}`);
devLog(`[PDFParserService.saveMatchesToDatabase] - Match now has: ${currentValues.join(', ')}`);
} else {
devLog(`[PDFParserService.saveMatchesToDatabase] - No matching match found for guest team: "${matchData.guestTeamName}"`);
// Fallback: Versuche Teams direkt zu finden
const homeTeam = await Team.findOne({
@@ -619,9 +574,6 @@ class PDFParserService {
where: { clubId: matchData.clubId },
attributes: ['id', 'name']
});
devLog(`[PDFParserService.saveMatchesToDatabase] - Available teams for club ${matchData.clubId}:`, allTeams.map(t => t.name));
devLog(`[PDFParserService.saveMatchesToDatabase] - Looking for home team: "${matchData.homeTeamName}"`);
devLog(`[PDFParserService.saveMatchesToDatabase] - Looking for guest team: "${matchData.guestTeamName}"`);
// Versuche Fuzzy-Matching für Team-Namen
const homeTeamFuzzy = allTeams.find(t =>
@@ -634,10 +586,8 @@ class PDFParserService {
);
if (homeTeamFuzzy) {
devLog(`[PDFParserService.saveMatchesToDatabase] - Fuzzy match found for home team: "${homeTeamFuzzy.name}"`);
}
if (guestTeamFuzzy) {
devLog(`[PDFParserService.saveMatchesToDatabase] - Fuzzy match found for guest team: "${guestTeamFuzzy.name}"`);
}
}
@@ -670,7 +620,6 @@ class PDFParserService {
locationId: 1 // Default Location, kann später angepasst werden
});
results.created++;
devLog(`[PDFParserService.saveMatchesToDatabase] - Created new match: ${matchData.homeTeamName} vs ${matchData.guestTeamName}`);
}
} catch (matchError) {
console.error('[PDFParserService.saveMatchesToDatabase] - Error:', matchError);
@@ -678,7 +627,6 @@ class PDFParserService {
}
}
devLog('[PDFParserService.saveMatchesToDatabase] - Results:', results);
return results;
} catch (error) {
console.error('[PDFParserService.saveMatchesToDatabase] - Error:', error);

9
backend/services/predefinedActivityService.js
View File

@@ -8,7 +8,6 @@ import { Op } from 'sequelize';
import { devLog } from '../utils/logger.js';
class PredefinedActivityService {
async createPredefinedActivity(data) {
devLog('[PredefinedActivityService::createPredefinedActivity] - Creating predefined activity');
return await PredefinedActivity.create({
name: data.name,
code: data.code,
@@ -21,10 +20,8 @@ class PredefinedActivityService {
}
async updatePredefinedActivity(id, data) {
devLog(`[PredefinedActivityService::updatePredefinedActivity] - Updating predefined activity with id: ${id}`);
const activity = await PredefinedActivity.findByPk(id);
if (!activity) {
devLog('[PredefinedActivityService::updatePredefinedActivity] - Activity not found');
throw new Error('Predefined activity not found');
}
return await activity.update({
@@ -39,7 +36,6 @@ class PredefinedActivityService {
}
async getAllPredefinedActivities() {
devLog('[PredefinedActivityService::getAllPredefinedActivities] - Fetching all predefined activities');
return await PredefinedActivity.findAll({
order: [
[sequelize.literal('code IS NULL'), 'ASC'], // Non-null codes first
@@ -50,10 +46,8 @@ class PredefinedActivityService {
}
async getPredefinedActivityById(id) {
devLog(`[PredefinedActivityService::getPredefinedActivityById] - Fetching predefined activity with id: ${id}`);
const activity = await PredefinedActivity.findByPk(id);
if (!activity) {
devLog('[PredefinedActivityService::getPredefinedActivityById] - Activity not found');
throw new Error('Predefined activity not found');
}
return activity;
@@ -81,7 +75,6 @@ class PredefinedActivityService {
}
async mergeActivities(sourceId, targetId) {
devLog(`[PredefinedActivityService::mergeActivities] - Merge ${sourceId} -> ${targetId}`);
if (!sourceId || !targetId) throw new Error('sourceId and targetId are required');
if (Number(sourceId) === Number(targetId)) throw new Error('sourceId and targetId must differ');
@@ -121,7 +114,6 @@ class PredefinedActivityService {
}
async deduplicateActivities() {
devLog('[PredefinedActivityService::deduplicateActivities] - Start');
const all = await PredefinedActivity.findAll();
const nameToActivities = new Map();
for (const activity of all) {
@@ -143,7 +135,6 @@ class PredefinedActivityService {
mergedCount++;
}
}
devLog('[PredefinedActivityService::deduplicateActivities] - Done', { mergedCount, groupCount });
return { mergedCount, groupCount };
}
}

11
backend/services/seasonService.js
View File

@@ -26,7 +26,6 @@ class SeasonService {
static async getOrCreateCurrentSeason() {
try {
const currentSeasonString = this.getCurrentSeasonString();
devLog('[SeasonService.getOrCreateCurrentSeason] - Current season string:', currentSeasonString);
// Versuche die aktuelle Saison zu finden
let season = await Season.findOne({
@@ -35,13 +34,11 @@ class SeasonService {
// Falls nicht vorhanden, erstelle sie
if (!season) {
devLog('[SeasonService.getOrCreateCurrentSeason] - Creating new season:', currentSeasonString);
season = await Season.create({
season: currentSeasonString
});
}
devLog('[SeasonService.getOrCreateCurrentSeason] - Season found/created:', season.id);
return season;
} catch (error) {
console.error('[SeasonService.getOrCreateCurrentSeason] - Error:', error);
@@ -55,11 +52,9 @@ class SeasonService {
*/
static async getAllSeasons() {
try {
devLog('[SeasonService.getAllSeasons] - Getting all seasons');
const seasons = await Season.findAll({
order: [['season', 'DESC']] // Neueste zuerst
});
devLog('[SeasonService.getAllSeasons] - Found seasons:', seasons.length);
return seasons;
} catch (error) {
console.error('[SeasonService.getAllSeasons] - Error:', error);
@@ -74,7 +69,6 @@ class SeasonService {
*/
static async createSeason(seasonString) {
try {
devLog('[SeasonService.createSeason] - Creating season:', seasonString);
// Prüfe ob Saison bereits existiert
const existingSeason = await Season.findOne({
@@ -89,7 +83,6 @@ class SeasonService {
season: seasonString
});
devLog('[SeasonService.createSeason] - Season created with ID:', season.id);
return season;
} catch (error) {
console.error('[SeasonService.createSeason] - Error:', error);
@@ -104,9 +97,7 @@ class SeasonService {
*/
static async getSeasonById(seasonId) {
try {
devLog('[SeasonService.getSeasonById] - Getting season:', seasonId);
const season = await Season.findByPk(seasonId);
devLog('[SeasonService.getSeasonById] - Found season:', season ? 'yes' : 'no');
return season;
} catch (error) {
console.error('[SeasonService.getSeasonById] - Error:', error);
@@ -121,7 +112,6 @@ class SeasonService {
*/
static async deleteSeason(seasonId) {
try {
devLog('[SeasonService.deleteSeason] - Deleting season:', seasonId);
// Prüfe ob Saison verwendet wird
const season = await Season.findByPk(seasonId, {
@@ -148,7 +138,6 @@ class SeasonService {
where: { id: seasonId }
});
devLog('[SeasonService.deleteSeason] - Season deleted');
return true;
} catch (error) {
console.error('[SeasonService.deleteSeason] - Error:', error);

16
backend/services/teamDocumentService.js
View File

@@ -18,13 +18,6 @@ class TeamDocumentService {
*/
static async uploadDocument(file, clubTeamId, documentType) {
try {
devLog('[TeamDocumentService.uploadDocument] - Uploading document:', {
fileName: file.originalname,
clubTeamId,
documentType,
size: file.size
});
// Prüfe ob das Club-Team existiert
const clubTeam = await ClubTeam.findByPk(clubTeamId);
if (!clubTeam) {
@@ -62,7 +55,6 @@ class TeamDocumentService {
clubTeamId: clubTeamId
});
devLog('[TeamDocumentService.uploadDocument] - Document uploaded successfully:', teamDocument.id);
return teamDocument;
} catch (error) {
console.error('[TeamDocumentService.uploadDocument] - Error:', error);
@@ -77,14 +69,12 @@ class TeamDocumentService {
*/
static async getDocumentsByClubTeam(clubTeamId) {
try {
devLog('[TeamDocumentService.getDocumentsByClubTeam] - Getting documents for club team:', clubTeamId);
const documents = await TeamDocument.findAll({
where: { clubTeamId },
order: [['createdAt', 'DESC']]
});
devLog('[TeamDocumentService.getDocumentsByClubTeam] - Found documents:', documents.length);
return documents;
} catch (error) {
console.error('[TeamDocumentService.getDocumentsByClubTeam] - Error:', error);
@@ -99,7 +89,6 @@ class TeamDocumentService {
*/
static async getDocumentById(documentId) {
try {
devLog('[TeamDocumentService.getDocumentById] - Getting document:', documentId);
const document = await TeamDocument.findByPk(documentId, {
include: [{
@@ -109,7 +98,6 @@ class TeamDocumentService {
}]
});
devLog('[TeamDocumentService.getDocumentById] - Found document:', document ? 'yes' : 'no');
return document;
} catch (error) {
console.error('[TeamDocumentService.getDocumentById] - Error:', error);
@@ -124,7 +112,6 @@ class TeamDocumentService {
*/
static async deleteDocument(documentId) {
try {
devLog('[TeamDocumentService.deleteDocument] - Deleting document:', documentId);
const document = await TeamDocument.findByPk(documentId);
if (!document) {
@@ -141,7 +128,6 @@ class TeamDocumentService {
where: { id: documentId }
});
devLog('[TeamDocumentService.deleteDocument] - Deleted rows:', deletedRows);
return deletedRows > 0;
} catch (error) {
console.error('[TeamDocumentService.deleteDocument] - Error:', error);
@@ -157,7 +143,6 @@ class TeamDocumentService {
*/
static async deleteDocumentsByType(clubTeamId, documentType) {
try {
devLog('[TeamDocumentService.deleteDocumentsByType] - Deleting documents by type:', clubTeamId, documentType);
const documents = await TeamDocument.findAll({
where: { clubTeamId, documentType }
@@ -177,7 +162,6 @@ class TeamDocumentService {
where: { clubTeamId, documentType }
});
devLog('[TeamDocumentService.deleteDocumentsByType] - Deleted documents:', deletedRows);
return deletedRows;
} catch (error) {
console.error('[TeamDocumentService.deleteDocumentsByType] - Error:', error);

12
backend/services/teamService.js
View File

@@ -8,7 +8,6 @@ import { devLog } from '../utils/logger.js';
class TeamService {
static async getAllTeamsByClub(clubId, seasonId = null) {
try {
devLog('[TeamService.getAllTeamsByClub] - Getting teams for club:', clubId, 'season:', seasonId);
// Wenn keine Saison angegeben, verwende die aktuelle
if (!seasonId) {
@@ -32,7 +31,6 @@ class TeamService {
],
order: [['name', 'ASC']]
});
devLog('[TeamService.getAllTeamsByClub] - Found teams:', teams.length);
return teams;
} catch (error) {
console.error('[TeamService.getAllTeamsByClub] - Error:', error);
@@ -42,7 +40,6 @@ class TeamService {
static async getTeamById(teamId) {
try {
devLog('[TeamService.getTeamById] - Getting team:', teamId);
const team = await Team.findByPk(teamId, {
include: [
{
@@ -62,7 +59,6 @@ class TeamService {
}
]
});
devLog('[TeamService.getTeamById] - Found team:', team ? 'yes' : 'no');
return team;
} catch (error) {
console.error('[TeamService.getTeamById] - Error:', error);
@@ -72,7 +68,6 @@ class TeamService {
static async createTeam(teamData) {
try {
devLog('[TeamService.createTeam] - Creating team:', teamData);
// Wenn keine Saison angegeben, verwende die aktuelle
if (!teamData.seasonId) {
@@ -81,7 +76,6 @@ class TeamService {
}
const team = await Team.create(teamData);
devLog('[TeamService.createTeam] - Team created with ID:', team.id);
return team;
} catch (error) {
console.error('[TeamService.createTeam] - Error:', error);
@@ -91,11 +85,9 @@ class TeamService {
static async updateTeam(teamId, updateData) {
try {
devLog('[TeamService.updateTeam] - Updating team:', teamId, updateData);
const [updatedRowsCount] = await Team.update(updateData, {
where: { id: teamId }
});
devLog('[TeamService.updateTeam] - Updated rows:', updatedRowsCount);
return updatedRowsCount > 0;
} catch (error) {
console.error('[TeamService.updateTeam] - Error:', error);
@@ -105,11 +97,9 @@ class TeamService {
static async deleteTeam(teamId) {
try {
devLog('[TeamService.deleteTeam] - Deleting team:', teamId);
const deletedRowsCount = await Team.destroy({
where: { id: teamId }
});
devLog('[TeamService.deleteTeam] - Deleted rows:', deletedRowsCount);
return deletedRowsCount > 0;
} catch (error) {
console.error('[TeamService.deleteTeam] - Error:', error);
@@ -119,7 +109,6 @@ class TeamService {
static async getLeaguesByClub(clubId, seasonId = null) {
try {
devLog('[TeamService.getLeaguesByClub] - Getting leagues for club:', clubId, 'season:', seasonId);
// Wenn keine Saison angegeben, verwende die aktuelle
if (!seasonId) {
@@ -132,7 +121,6 @@ class TeamService {
attributes: ['id', 'name', 'seasonId'],
order: [['name', 'ASC']]
});
devLog('[TeamService.getLeaguesByClub] - Found leagues:', leagues.length);
return leagues;
} catch (error) {
console.error('[TeamService.getLeaguesByClub] - Error:', error);

6
backend/services/tournamentService.js
View File

@@ -203,11 +203,8 @@ class TournamentService {
}
// 4) Round‑Robin anlegen wie gehabt - NUR innerhalb jeder Gruppe
devLog(`[fillGroups] Erstelle Matches für ${groups.length} Gruppen`);
for (const g of groups) {
devLog(`[fillGroups] Verarbeite Gruppe ${g.id}`);
const gm = await TournamentMember.findAll({ where: { groupId: g.id } });
devLog(`[fillGroups] Gruppe ${g.id} hat ${gm.length} Teilnehmer:`, gm.map(m => ({ id: m.id, name: m.member?.firstName + ' ' + m.member?.lastName })));
if (gm.length < 2) {
console.warn(`Gruppe ${g.id} hat nur ${gm.length} Teilnehmer - keine Matches erstellt`);
@@ -215,10 +212,8 @@ class TournamentService {
}
const rounds = this.generateRoundRobinSchedule(gm);
devLog(`[fillGroups] Gruppe ${g.id} hat ${rounds.length} Runden`);
for (let roundIndex = 0; roundIndex < rounds.length; roundIndex++) {
devLog(`[fillGroups] Runde ${roundIndex + 1} für Gruppe ${g.id}:`, rounds[roundIndex]);
for (const [p1Id, p2Id] of rounds[roundIndex]) {
// Prüfe, ob beide Spieler zur gleichen Gruppe gehören
const p1 = gm.find(p => p.id === p1Id);
@@ -232,7 +227,6 @@ class TournamentService {
player2Id: p2Id,
groupRound: roundIndex + 1
});
devLog(`[fillGroups] Match erstellt: ${match.id} - Spieler ${p1Id} vs ${p2Id} in Gruppe ${g.id}`);
} else {
console.warn(`Spieler gehören nicht zur gleichen Gruppe: ${p1Id} (${p1?.groupId}) vs ${p2Id} (${p2?.groupId}) in Gruppe ${g.id}`);
}

4
backend/utils/userUtils.js
View File

@@ -42,7 +42,6 @@ export const getUserByToken = async (token) => {
export const hasUserClubAccess = async (userId, clubId) => {
try {
devLog('[hasUserClubAccess]');
const userClub = await UserClub.findOne({
where: {
user_id: userId,
@@ -62,11 +61,9 @@ export const checkAccess = async (userToken, clubId) => {
const user = await getUserByToken(userToken);
const hasAccess = await hasUserClubAccess(user.id, clubId);
if (!hasAccess) {
devLog('[checkAccess] - no club access');
throw new HttpError('noaccess', 403);
}
} catch (error) {
devLog('[checkAccess] - error:', error);
throw error;
}
};
@@ -76,7 +73,6 @@ export const checkGlobalAccess = async (userToken) => {
const user = await getUserByToken(userToken);
return user; // Einfach den User zurückgeben, da globale Zugriffe nur Authentifizierung benötigen
} catch (error) {
devLog('[checkGlobalAccess] - error:', error);
throw error;
}
};