56be4b76c0
All checks were successful
Deploy to production / deploy (push) Successful in 3m3s
- Added new political powers and benefits functionalities, including reputation ticks, tax jurisdiction management, and appointment capabilities. - Introduced a new job for periodic reputation updates and created necessary database tables for tracking political benefits. - Enhanced the FalukantController and services to support new endpoints for managing political powers and appointments. - Updated localization files to reflect new features and improve user experience across multiple languages. - Modified the UI to display new political powers and benefits, ensuring accurate representation in the PoliticsView.
527 lines
21 KiB
JavaScript
527 lines
21 KiB
JavaScript
/**
|
|
* Politische Amtsbefugnisse: Steuern setzen, Ernennungen, Meta (Frei-Slots, nächster Ansehens-Tick).
|
|
* Reputation-Ticks: backend/jobs/politicalBenefitsTick.js
|
|
*/
|
|
import { Op, QueryTypes } from 'sequelize';
|
|
import { differenceInDays } from 'date-fns';
|
|
import { sequelize } from '../utils/sequelize.js';
|
|
import User from '../models/community/user.js';
|
|
import FalukantUser from '../models/falukant/data/user.js';
|
|
import FalukantCharacter from '../models/falukant/data/character.js';
|
|
import TitleOfNobility from '../models/falukant/type/title_of_nobility.js';
|
|
import TitleBenefit from '../models/falukant/type/title_benefit.js';
|
|
import PoliticalOffice from '../models/falukant/data/political_office.js';
|
|
import PoliticalOfficeType from '../models/falukant/type/political_office_type.js';
|
|
import PoliticalOfficeBenefit from '../models/falukant/predefine/political_office_benefit.js';
|
|
import PoliticalOfficeBenefitType from '../models/falukant/type/political_office_benefit_type.js';
|
|
import RegionData from '../models/falukant/data/region.js';
|
|
import RegionType from '../models/falukant/type/region.js';
|
|
import RegionTaxHistory from '../models/falukant/data/region_tax_history.js';
|
|
import PoliticalAppointment from '../models/falukant/data/political_appointment.js';
|
|
import PoliticalOfficeHistory from '../models/falukant/log/political_office_history.js';
|
|
import PoliticalBenefitLastTick from '../models/falukant/data/political_benefit_last_tick.js';
|
|
import { notifyUser } from '../utils/socket.js';
|
|
|
|
const TAX_MIN = 0;
|
|
const TAX_MAX = 25;
|
|
const MAX_FREE_LOVER_SLOTS = 5;
|
|
const MIN_AGE_POLITICS_DAYS = 16;
|
|
|
|
function calcAgeDays(birthdate) {
|
|
const b = new Date(birthdate);
|
|
b.setHours(0, 0, 0, 0);
|
|
const now = new Date();
|
|
now.setHours(0, 0, 0, 0);
|
|
return differenceInDays(now, b);
|
|
}
|
|
|
|
async function loadContext(hashedUserId) {
|
|
const user = await FalukantUser.findOne({
|
|
include: [{ model: User, as: 'user', attributes: ['hashedId'], where: { hashedId: hashedUserId } }]
|
|
});
|
|
if (!user) {
|
|
const err = new Error('User not found');
|
|
err.status = 404;
|
|
throw err;
|
|
}
|
|
const character = await FalukantCharacter.findOne({
|
|
where: { userId: user.id },
|
|
include: [{ model: TitleOfNobility, as: 'nobleTitle', attributes: ['id', 'labelTr'] }]
|
|
});
|
|
if (!character) {
|
|
const err = new Error('No character');
|
|
err.status = 404;
|
|
throw err;
|
|
}
|
|
return { user, character };
|
|
}
|
|
|
|
async function allowedOfficeNamesForTitle(titleId) {
|
|
const benefits = await TitleBenefit.findAll({
|
|
where: { titleId, benefitType: 'office_eligibility' },
|
|
attributes: ['parameters']
|
|
});
|
|
const names = new Set();
|
|
for (const b of benefits) {
|
|
const arr = b.parameters?.officeTypeNames;
|
|
if (Array.isArray(arr)) arr.forEach((n) => names.add(n));
|
|
}
|
|
return names;
|
|
}
|
|
|
|
async function getDescendantRegionIds(rootId) {
|
|
const rows = await sequelize.query(
|
|
`
|
|
WITH RECURSIVE sub AS (
|
|
SELECT id FROM falukant_data.region WHERE id = :root
|
|
UNION ALL
|
|
SELECT r.id FROM falukant_data.region r
|
|
INNER JOIN sub ON r.parent_id = sub.id
|
|
)
|
|
SELECT id FROM sub
|
|
`,
|
|
{ replacements: { root: rootId }, type: QueryTypes.SELECT }
|
|
);
|
|
return rows.map((r) => r.id);
|
|
}
|
|
|
|
async function getAllRegionIds() {
|
|
const rows = await RegionData.findAll({ attributes: ['id'] });
|
|
return rows.map((r) => r.id);
|
|
}
|
|
|
|
async function regionIdsForTaxScope(scope, officeRegionId) {
|
|
if (scope === 'national') {
|
|
return getAllRegionIds();
|
|
}
|
|
return getDescendantRegionIds(officeRegionId);
|
|
}
|
|
|
|
async function mergeTaxRegions(heldOffices) {
|
|
const allowed = new Map();
|
|
for (const po of heldOffices) {
|
|
const { officeTypeId, regionId } = po;
|
|
const benefits = await PoliticalOfficeBenefit.findAll({
|
|
where: { officeTypeId },
|
|
include: [
|
|
{
|
|
model: PoliticalOfficeBenefitType,
|
|
as: 'benefitDefinition',
|
|
attributes: ['tr'],
|
|
required: true,
|
|
where: { tr: { [Op.in]: ['set_regional_tax', 'set_regionl_tax'] } }
|
|
}
|
|
]
|
|
});
|
|
for (const br of benefits) {
|
|
const v = br.value && typeof br.value === 'object' ? br.value : {};
|
|
const scope = typeof v.scope === 'string' ? v.scope : 'local';
|
|
const ids = scope === 'local' ? [regionId] : await regionIdsForTaxScope(scope, regionId);
|
|
for (const rid of ids) {
|
|
const prev = allowed.get(rid) || { scopes: [], officeIds: [] };
|
|
prev.scopes.push(scope);
|
|
prev.officeIds.push(po.id);
|
|
allowed.set(rid, prev);
|
|
}
|
|
}
|
|
}
|
|
return allowed;
|
|
}
|
|
|
|
export async function sumFreePoliticalLoverSlotsForCharacter(characterId) {
|
|
const held = await PoliticalOffice.findAll({
|
|
where: { characterId },
|
|
attributes: ['officeTypeId']
|
|
});
|
|
if (!held.length) return 0;
|
|
const typeIds = [...new Set(held.map((h) => h.officeTypeId))];
|
|
const rows = await PoliticalOfficeBenefit.findAll({
|
|
where: { officeTypeId: { [Op.in]: typeIds } },
|
|
include: [
|
|
{
|
|
model: PoliticalOfficeBenefitType,
|
|
as: 'benefitDefinition',
|
|
attributes: ['tr'],
|
|
required: true,
|
|
where: { tr: 'free_lover_slots' }
|
|
}
|
|
]
|
|
});
|
|
let sum = 0;
|
|
for (const r of rows) {
|
|
const v = r.value && typeof r.value === 'object' ? r.value : {};
|
|
sum += Math.max(0, Number(v.count ?? 0));
|
|
}
|
|
return Math.min(MAX_FREE_LOVER_SLOTS, sum);
|
|
}
|
|
|
|
class FalukantPoliticalPowersService {
|
|
async getMyPowers(hashedUserId) {
|
|
const { character } = await loadContext(hashedUserId);
|
|
const held = await PoliticalOffice.findAll({
|
|
where: { characterId: character.id },
|
|
include: [
|
|
{ model: PoliticalOfficeType, as: 'type', attributes: ['id', 'name'] },
|
|
{ model: RegionData, as: 'region', attributes: ['id', 'name'] }
|
|
]
|
|
});
|
|
const freeLoverSlots = await sumFreePoliticalLoverSlotsForCharacter(character.id);
|
|
const reputationPreview = await this._reputationTickPreview(character.id, held);
|
|
const canSetTax = (await mergeTaxRegions(held)).size > 0;
|
|
const appointBenefits = await this._collectAppointBenefits(held);
|
|
|
|
return {
|
|
heldOffices: held.map((p) => ({
|
|
id: p.id,
|
|
officeTypeName: p.type?.name,
|
|
regionName: p.region?.name,
|
|
regionId: p.regionId
|
|
})),
|
|
freeLoverSlots,
|
|
reputationPeriodic: reputationPreview,
|
|
canSetTax,
|
|
canAppoint: appointBenefits.length > 0,
|
|
appointOfficeTrs: [...new Set(appointBenefits.flatMap((x) => x.officeTrs))]
|
|
};
|
|
}
|
|
|
|
async _reputationTickPreview(characterId, heldOffices) {
|
|
const out = [];
|
|
const typeIds = [...new Set(heldOffices.map((h) => h.officeTypeId))];
|
|
const benefitRows = await PoliticalOfficeBenefit.findAll({
|
|
where: { officeTypeId: { [Op.in]: typeIds } },
|
|
include: [
|
|
{
|
|
model: PoliticalOfficeBenefitType,
|
|
as: 'benefitDefinition',
|
|
attributes: ['tr'],
|
|
required: true,
|
|
where: { tr: 'reputation_periodic' }
|
|
}
|
|
]
|
|
});
|
|
const byOfficeType = new Map();
|
|
for (const br of benefitRows) {
|
|
if (!byOfficeType.has(br.officeTypeId)) byOfficeType.set(br.officeTypeId, []);
|
|
byOfficeType.get(br.officeTypeId).push(br);
|
|
}
|
|
const now = Date.now();
|
|
for (const po of heldOffices) {
|
|
const rows = byOfficeType.get(po.officeTypeId) || [];
|
|
for (const br of rows) {
|
|
const v = br.value && typeof br.value === 'object' ? br.value : {};
|
|
const intervalDays = Math.max(1, Number(v.intervalDays ?? v.everyDays ?? 7));
|
|
const gain = Math.max(1, Number(v.gain ?? 1));
|
|
let tick = await PoliticalBenefitLastTick.findOne({
|
|
where: { characterId, politicalOfficeBenefitId: br.id }
|
|
});
|
|
const baseTime = tick?.lastTickAt ? new Date(tick.lastTickAt).getTime() : new Date(po.createdAt).getTime();
|
|
const daysSince = Math.floor((now - baseTime) / 86400000);
|
|
const daysUntil = Math.max(0, intervalDays - daysSince);
|
|
out.push({
|
|
officeTypeName: po.type?.name,
|
|
intervalDays,
|
|
gain,
|
|
daysUntilNext: daysUntil,
|
|
benefitId: br.id
|
|
});
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
async _collectAppointBenefits(heldOffices) {
|
|
const list = [];
|
|
const typeIds = [...new Set(heldOffices.map((h) => h.officeTypeId))];
|
|
const benefitRows = await PoliticalOfficeBenefit.findAll({
|
|
where: { officeTypeId: { [Op.in]: typeIds } },
|
|
include: [
|
|
{
|
|
model: PoliticalOfficeBenefitType,
|
|
as: 'benefitDefinition',
|
|
attributes: ['tr'],
|
|
required: true,
|
|
where: { tr: 'appoint_politicians' }
|
|
}
|
|
]
|
|
});
|
|
const byOfficeType = new Map();
|
|
for (const br of benefitRows) {
|
|
if (!byOfficeType.has(br.officeTypeId)) byOfficeType.set(br.officeTypeId, []);
|
|
byOfficeType.get(br.officeTypeId).push(br);
|
|
}
|
|
for (const po of heldOffices) {
|
|
const rows = byOfficeType.get(po.officeTypeId) || [];
|
|
for (const br of rows) {
|
|
const v = br.value && typeof br.value === 'object' ? br.value : {};
|
|
const officeTrs = Array.isArray(v.officeTrs) ? v.officeTrs.filter((x) => typeof x === 'string') : [];
|
|
if (officeTrs.length) {
|
|
list.push({ officeTrs, anchorRegionId: po.regionId, sourceOfficeId: po.id });
|
|
}
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
async getTaxJurisdiction(hashedUserId) {
|
|
const { character } = await loadContext(hashedUserId);
|
|
const held = await PoliticalOffice.findAll({
|
|
where: { characterId: character.id },
|
|
include: [
|
|
{ model: PoliticalOfficeType, as: 'type', attributes: ['name'] },
|
|
{ model: RegionData, as: 'region', attributes: ['id', 'name'], include: [{ model: RegionType, as: 'regionType', attributes: ['labelTr'] }] }
|
|
]
|
|
});
|
|
const merged = await mergeTaxRegions(held);
|
|
const regionIds = [...merged.keys()];
|
|
if (!regionIds.length) return { regions: [], taxMin: TAX_MIN, taxMax: TAX_MAX };
|
|
const regions = await RegionData.findAll({
|
|
where: { id: { [Op.in]: regionIds } },
|
|
include: [{ model: RegionType, as: 'regionType', attributes: ['labelTr'] }],
|
|
order: [['name', 'ASC']]
|
|
});
|
|
return {
|
|
taxMin: TAX_MIN,
|
|
taxMax: TAX_MAX,
|
|
regions: regions.map((r) => ({
|
|
id: r.id,
|
|
name: r.name,
|
|
regionType: r.regionType?.labelTr,
|
|
taxPercent: Number(r.taxPercent)
|
|
}))
|
|
};
|
|
}
|
|
|
|
async setRegionTax(hashedUserId, regionId, percentRaw) {
|
|
const { character } = await loadContext(hashedUserId);
|
|
const held = await PoliticalOffice.findAll({ where: { characterId: character.id } });
|
|
const merged = await mergeTaxRegions(held);
|
|
if (!merged.has(regionId)) {
|
|
const err = new Error('no_tax_power_in_region');
|
|
err.status = 403;
|
|
throw err;
|
|
}
|
|
let percent = Number(percentRaw);
|
|
if (!Number.isFinite(percent)) {
|
|
const err = new Error('invalid_percent');
|
|
err.status = 400;
|
|
throw err;
|
|
}
|
|
percent = Math.round(percent * 100) / 100;
|
|
if (percent < TAX_MIN || percent > TAX_MAX) {
|
|
const err = new Error('percent_out_of_range');
|
|
err.status = 400;
|
|
throw err;
|
|
}
|
|
const region = await RegionData.findByPk(regionId);
|
|
if (!region) {
|
|
const err = new Error('region_not_found');
|
|
err.status = 404;
|
|
throw err;
|
|
}
|
|
const oldVal = Number(region.taxPercent);
|
|
const meta = merged.get(regionId);
|
|
const politicalOfficeId = meta?.officeIds?.[0] ?? null;
|
|
await sequelize.transaction(async (t) => {
|
|
await region.update({ taxPercent: percent }, { transaction: t });
|
|
await RegionTaxHistory.create(
|
|
{
|
|
regionId,
|
|
oldTaxPercent: oldVal,
|
|
newTaxPercent: percent,
|
|
setterCharacterId: character.id,
|
|
politicalOfficeId
|
|
},
|
|
{ transaction: t }
|
|
);
|
|
});
|
|
return { regionId, taxPercent: percent };
|
|
}
|
|
|
|
async getAppointableOffices(hashedUserId) {
|
|
const { character } = await loadContext(hashedUserId);
|
|
const held = await PoliticalOffice.findAll({
|
|
where: { characterId: character.id },
|
|
include: [{ model: PoliticalOfficeType, as: 'type', attributes: ['name'] }]
|
|
});
|
|
const appointBlocks = await this._collectAppointBenefits(held);
|
|
const allowedTargetNames = new Set(appointBlocks.flatMap((b) => b.officeTrs));
|
|
if (!allowedTargetNames.size) return [];
|
|
|
|
const results = [];
|
|
for (const block of appointBlocks) {
|
|
const subtreeIds = await getDescendantRegionIds(block.anchorRegionId);
|
|
const eligibleRegionIds = new Set([block.anchorRegionId, ...subtreeIds]);
|
|
for (const officeTr of block.officeTrs) {
|
|
const officeType = await PoliticalOfficeType.findOne({ where: { name: officeTr } });
|
|
if (!officeType) continue;
|
|
for (const rid of eligibleRegionIds) {
|
|
const cnt = await PoliticalOffice.count({ where: { officeTypeId: officeType.id, regionId: rid } });
|
|
if (cnt >= officeType.seatsPerRegion) continue;
|
|
const reg = await RegionData.findByPk(rid, { attributes: ['id', 'name'] });
|
|
results.push({
|
|
officeTypeId: officeType.id,
|
|
officeTypeName: officeTr,
|
|
regionId: rid,
|
|
regionName: reg?.name,
|
|
seatsFree: officeType.seatsPerRegion - cnt,
|
|
sourceOfficeId: block.sourceOfficeId
|
|
});
|
|
}
|
|
}
|
|
}
|
|
const key = (x) => `${x.officeTypeId}-${x.regionId}`;
|
|
const dedup = new Map();
|
|
for (const r of results) {
|
|
if (!dedup.has(key(r)) || r.seatsFree > dedup.get(key(r)).seatsFree) dedup.set(key(r), r);
|
|
}
|
|
return [...dedup.values()];
|
|
}
|
|
|
|
async createAppointment(hashedUserId, { targetCharacterId, officeTypeId, regionId }) {
|
|
const { character: appointer } = await loadContext(hashedUserId);
|
|
const tid = parseInt(targetCharacterId, 10);
|
|
const otid = parseInt(officeTypeId, 10);
|
|
const rid = parseInt(regionId, 10);
|
|
if ([tid, otid, rid].some((n) => Number.isNaN(n))) {
|
|
const err = new Error('invalid_payload');
|
|
err.status = 400;
|
|
throw err;
|
|
}
|
|
if (tid === appointer.id) {
|
|
const err = new Error('cannot_appoint_self');
|
|
err.status = 400;
|
|
throw err;
|
|
}
|
|
const target = await FalukantCharacter.findByPk(tid, {
|
|
include: [{ model: TitleOfNobility, as: 'nobleTitle', attributes: ['labelTr'] }]
|
|
});
|
|
if (!target?.userId) {
|
|
const err = new Error('target_must_be_player');
|
|
err.status = 400;
|
|
throw err;
|
|
}
|
|
if (target.nobleTitle?.labelTr === 'noncivil') {
|
|
const err = new Error('target_title_blocked');
|
|
err.status = 400;
|
|
throw err;
|
|
}
|
|
if (calcAgeDays(target.birthdate) < MIN_AGE_POLITICS_DAYS) {
|
|
const err = new Error('target_too_young');
|
|
err.status = 400;
|
|
throw err;
|
|
}
|
|
const officeType = await PoliticalOfficeType.findByPk(otid);
|
|
if (!officeType) {
|
|
const err = new Error('office_type_not_found');
|
|
err.status = 404;
|
|
throw err;
|
|
}
|
|
const allowedNames = await allowedOfficeNamesForTitle(target.titleOfNobility);
|
|
if (allowedNames.size > 0 && !allowedNames.has(officeType.name)) {
|
|
const err = new Error('target_title_not_eligible');
|
|
err.status = 400;
|
|
throw err;
|
|
}
|
|
const held = await PoliticalOffice.findAll({ where: { characterId: appointer.id } });
|
|
const appointBlocks = await this._collectAppointBenefits(held);
|
|
let appointAllowed = false;
|
|
for (const b of appointBlocks) {
|
|
const subtree = new Set([b.anchorRegionId, ...(await getDescendantRegionIds(b.anchorRegionId))]);
|
|
for (const tr of b.officeTrs) {
|
|
if (tr === officeType.name && subtree.has(rid)) {
|
|
appointAllowed = true;
|
|
break;
|
|
}
|
|
}
|
|
if (appointAllowed) break;
|
|
}
|
|
if (!appointAllowed) {
|
|
const err = new Error('appoint_not_allowed');
|
|
err.status = 403;
|
|
throw err;
|
|
}
|
|
const dup = await PoliticalOffice.findOne({
|
|
where: { characterId: tid, officeTypeId: otid, regionId: rid }
|
|
});
|
|
if (dup) {
|
|
const err = new Error('already_holds_office');
|
|
err.status = 409;
|
|
throw err;
|
|
}
|
|
const cnt = await PoliticalOffice.count({ where: { officeTypeId: otid, regionId: rid } });
|
|
if (cnt >= officeType.seatsPerRegion) {
|
|
const err = new Error('no_seat_available');
|
|
err.status = 409;
|
|
throw err;
|
|
}
|
|
|
|
const start = new Date();
|
|
const end = new Date(start);
|
|
end.setFullYear(end.getFullYear() + (officeType.termLength || 4));
|
|
|
|
let newOffice;
|
|
await sequelize.transaction(async (t) => {
|
|
newOffice = await PoliticalOffice.create(
|
|
{ officeTypeId: otid, characterId: tid, regionId: rid },
|
|
{ transaction: t }
|
|
);
|
|
await PoliticalOfficeHistory.create(
|
|
{
|
|
characterId: tid,
|
|
officeTypeId: otid,
|
|
startDate: start,
|
|
endDate: end
|
|
},
|
|
{ transaction: t }
|
|
);
|
|
await PoliticalAppointment.create(
|
|
{
|
|
appointerCharacterId: appointer.id,
|
|
targetCharacterId: tid,
|
|
officeTypeId: otid,
|
|
regionId: rid,
|
|
status: 'completed',
|
|
completedPoliticalOfficeId: newOffice.id
|
|
},
|
|
{ transaction: t }
|
|
);
|
|
});
|
|
|
|
const targetUser = await FalukantUser.findOne({ where: { id: target.userId }, include: [{ model: User, as: 'user', attributes: ['hashedId'] }] });
|
|
if (targetUser?.user?.hashedId) {
|
|
notifyUser(targetUser.user.hashedId, 'falukantUpdateStatus', {});
|
|
}
|
|
const appUser = await FalukantUser.findOne({ where: { id: appointer.userId }, include: [{ model: User, as: 'user', attributes: ['hashedId'] }] });
|
|
if (appUser?.user?.hashedId) {
|
|
notifyUser(appUser.user.hashedId, 'falukantUpdateStatus', {});
|
|
}
|
|
|
|
return { politicalOfficeId: newOffice.id };
|
|
}
|
|
|
|
async getRegionTaxHistory(hashedUserId, regionId, limit = 5) {
|
|
const { character } = await loadContext(hashedUserId);
|
|
const held = await PoliticalOffice.findAll({ where: { characterId: character.id } });
|
|
const merged = await mergeTaxRegions(held);
|
|
if (!merged.has(regionId)) {
|
|
const err = new Error('no_tax_power_in_region');
|
|
err.status = 403;
|
|
throw err;
|
|
}
|
|
const rows = await RegionTaxHistory.findAll({
|
|
where: { regionId },
|
|
order: [['createdAt', 'DESC']],
|
|
limit,
|
|
attributes: ['oldTaxPercent', 'newTaxPercent', 'createdAt']
|
|
});
|
|
return rows.map((r) => ({
|
|
oldTaxPercent: Number(r.oldTaxPercent),
|
|
newTaxPercent: Number(r.newTaxPercent),
|
|
createdAt: r.createdAt
|
|
}));
|
|
}
|
|
}
|
|
|
|
export default new FalukantPoliticalPowersService();
|