Start implementation of branches, new form element tabledropdown, model improvements

This commit is contained in:
Torsten Schulz
2024-12-06 23:35:28 +01:00
parent 8c15fb7f2b
commit 1bb2bd49d5
57 changed files with 2176 additions and 170 deletions

View File

@@ -1,7 +1,284 @@
class FalukantService {
async exampleMethod() {
// Logik für die Methode
import BaseService from './BaseService.js';
import FalukantPredefineFirstname from '../models/falukant/predefine/firstname.js';
import FalukantPredefineLastname from '../models/falukant/predefine/lastname.js';
import FalukantUser from '../models/falukant/data/user.js';
import User from '../models/community/user.js';
import FalukantCharacter from '../models/falukant/data/character.js';
import RegionData from '../models/falukant/data/region.js';
import RegionType from '../models/falukant/type/region.js';
import { Sequelize } from 'sequelize';
import FalukantStock from '../models/falukant/data/stock.js';
import FalukantStockType from '../models/falukant/type/stock.js';
import { notifyUser } from '../utils/socket.js';
import { differenceInDays } from 'date-fns';
import TitleOfNobility from '../models/falukant/type/title_of_nobility.js';
import Branch from '../models/falukant/data/branch.js';
import BranchType from '../models/falukant/type/branch.js';
class FalukantService extends BaseService {
async getFalukantUserByHashedId(hashedId) {
const falukantUser = await FalukantUser.findOne({
include: [{
model: User,
as: 'user',
attributes: ['username', 'hashedId'],
where: {
hashedId: hashedId
},
}
],
});
return falukantUser;
}
async getUser(hashedUserId) {
const falukantUser = await FalukantUser.findOne({
include: [{
model: User,
as: 'user',
attributes: ['username', 'hashedId'],
where: {
hashedId: hashedUserId
},
},
{
model: FalukantCharacter,
as: 'character',
include: [
{
model: FalukantPredefineFirstname,
as: 'definedFirstName',
attributes: ['name']
},
{
model: FalukantPredefineLastname,
as: 'definedLastName',
attributes: ['name']
},
{
model: TitleOfNobility,
as: 'nobleTitle',
attributes: ['labelTr']
}
],
attributes: ['birthdate', 'gender'],
},
{
model: RegionData,
as: 'mainBranchRegion',
include: [
{
model: RegionType,
as: 'regionType',
}
],
attributes: ['name'],
},
{
model: Branch,
as: 'branches',
include: [
{
model: BranchType,
as: 'branchType',
attributes: ['labelTr']
},
{
model: RegionData,
as: 'region',
include: [
{
model: RegionType,
as: 'regionType',
}
],
attributes: ['name'],
}
]
}
],
attributes: ['money', 'creditAmount', 'todayCreditTaken'],
});
if (!falukantUser) {
throw new Error('User not found');
}
const character = falukantUser.character;
if (character && character.birthdate) {
const birthdate = new Date(character.birthdate);
birthdate.setHours(0);
birthdate.setMinutes(0);
const currentDate = new Date();
currentDate.setHours(0);
currentDate.setMinutes(0);
const ageInDays = differenceInDays(currentDate, birthdate);
character.setDataValue('age', ageInDays);
}
return falukantUser;
}
async randomFirstName(gender) {
const names = await FalukantPredefineFirstname.findAll({ where: { gender: gender } });
return names[Math.floor(Math.random() * names.length)].name;
}
async randomLastName() {
const names = await FalukantPredefineLastname.findAll();
return names[Math.floor(Math.random() * names.length)].name;
}
async createUser(hashedUserId, gender, firstName, lastName) {
try {
const user = await this.getUserByHashedId(hashedUserId);
const userExistsCheck = await FalukantUser.findOne({ where: { userId: user.id } });
if (userExistsCheck) {
throw new Error('User already exists in Falukant.');
}
let firstNameObject = await FalukantPredefineFirstname.findOne({ where: { name: firstName } });
let lastNameObject = await FalukantPredefineLastname.findOne({ where: { name: lastName } });
if (!firstNameObject) {
firstNameObject = await FalukantPredefineFirstname.create({ name: firstName, gender: gender });
}
if (!lastNameObject) {
lastNameObject = await FalukantPredefineLastname.create({ name: lastName });
}
const randomRegion = await RegionData.findOne({
order: Sequelize.fn('RANDOM'),
limit: 1,
include: [
{
model: RegionType,
as: 'regionType',
where: {
labelTr: 'city'
}
}
]
});
if (!randomRegion) {
throw new Error('No region found with the label "city".');
}
const titleOfNobility = await TitleOfNobility.findOne({ where: { labelTr: 'noncivil' } });
if (!titleOfNobility) {
throw new Error('No title of nobility found with the label "noncivil".');
}
const falukantUser = await FalukantUser.create({
userId: user.id,
money: 50.00,
creditAmount: 0.00,
todayCreditTaken: 0.00,
creditInterestRate: 0.00,
mainBranchRegionId: randomRegion.id,
});
const fourteenDaysAgo = new Date();
fourteenDaysAgo.setDate(fourteenDaysAgo.getDate() - 14);
const character = await FalukantCharacter.create({
userId: falukantUser.id,
regionId: randomRegion.id,
firstName: firstNameObject.id,
lastName: lastNameObject.id,
gender: gender,
birthdate: fourteenDaysAgo,
titleOfNobility: titleOfNobility.id,
});
await FalukantStock.create({
userId: falukantUser.id,
regionId: randomRegion.id,
stockTypeId: (await FalukantStockType.findOne({ where: [{ label_tr: 'wood' }] })).id,
quantity: 10,
});
falukantUser['character'] = character;
const branchType = await BranchType.findOne({ where: { labelTr: 'fullstack' } });
await Branch.create({
userId: falukantUser.id,
regionId: randomRegion.id,
branchTypeId: branchType.id,
})
notifyUser(user.hashedId, 'reloadmenu', {});
return falukantUser;
} catch (error) {
console.error('Error creating character');
console.log(error);
}
}
async getInfo(hashedUserId) {
try {
const user = await User.findOne({ where: { hashedId: hashedUserId } });
if (!user) {
throw new Error('User not found');
}
const falukantUser = await FalukantUser.findOne({
include: [{
model: User,
as: 'user',
attributes: ['hashedId'],
where: {
hashedId: hashedUserId
},
},
{
model: FalukantCharacter,
as: 'character',
attributes: ['birthdate', 'health'],
},
],
attributes: ['money']
});
if (!falukantUser) {
throw new Error('User not found');
}
const character = falukantUser.character;
if (character && character.birthdate) {
const birthdate = new Date(character.birthdate);
birthdate.setHours(0);
birthdate.setMinutes(0);
const currentDate = new Date();
currentDate.setHours(0);
currentDate.setMinutes(0);
const ageInDays = differenceInDays(currentDate, birthdate);
character.setDataValue('age', ageInDays);
}
return falukantUser;
} catch (error) {
console.error('Error getting character info');
console.log(error);
}
}
async getBranches(hashedUserId) {
try {
const falukantUser = await this.getFalukantUserByHashedId(hashedUserId);
if (!falukantUser) {
throw new Error('User not found');
}
const branches = await Branch.findAll({
where: { falukantUserId: falukantUser.id },
include: [
{
model: BranchType,
as: 'branchType',
attributes: ['labelTr'],
},
{
model: RegionData,
as: 'region',
attributes: ['name'],
}
],
attributes: ['id', 'regionId'],
order: [['branchTypeId', 'ASC']],
});
const enrichedBranches = branches.map(branch => ({
...branch.toJSON(),
isMainBranch: falukantUser.mainBranchRegionId === branch.regionId,
}));
return enrichedBranches;
} catch (error) {
console.error('Error in getBranches:', error);
throw new Error('Failed to retrieve branches');
}
}
}
export default new FalukantService();