42349e46c8
Änderungen: - Implementierung des neuen Routers für TaxiHighscore zur Verwaltung von Highscore-Daten. - Anpassung der Datenbankmodelle zur Unterstützung von TaxiHighscore-Associations. - Erweiterung der Vue-Komponenten zur Anzeige und Speicherung von Highscores im Taxi-Spiel. - Verbesserung der Statusanzeige im AppHeader zur besseren Benutzerinteraktion. Diese Anpassungen erweitern die Spielmechanik und Benutzererfahrung, indem sie die Verwaltung von Highscores integrieren und die Benutzeroberfläche optimieren.
833 lines
34 KiB
JavaScript
833 lines
34 KiB
JavaScript
import RoomType from './chat/room_type.js';
|
|
import ChatRight from './chat/rights.js';
|
|
import ChatUserRight from './chat/user_rights.js';
|
|
import ChatUser from './chat/user.js';
|
|
import Room from './chat/room.js';
|
|
import User from './community/user.js';
|
|
import UserParam from './community/user_param.js';
|
|
import UserParamType from './type/user_param.js';
|
|
import UserRightType from './type/user_right.js';
|
|
import UserRight from './community/user_right.js';
|
|
import SettingsType from './type/settings.js';
|
|
import UserParamValue from './type/user_param_value.js';
|
|
import InterestType from './type/interest.js';
|
|
import InterestTranslationType from './type/interest_translation.js';
|
|
import Interest from './community/interest.js';
|
|
import UserParamVisibilityType from './type/user_param_visibility.js';
|
|
import UserParamVisibility from './community/user_param_visibility.js';
|
|
import Folder from './community/folder.js';
|
|
import Image from './community/image.js';
|
|
import ImageVisibilityType from './type/image_visibility.js';
|
|
import ImageVisibilityUser from './community/image_visibility_user.js';
|
|
import FolderImageVisibility from './community/folder_image_visibility.js';
|
|
import ImageImageVisibility from './community/image_image_visibility.js';
|
|
import FolderVisibilityUser from './community/folder_visibility_user.js';
|
|
import GuestbookEntry from './community/guestbook.js';
|
|
import Forum from './forum/forum.js';
|
|
import Title from './forum/title.js';
|
|
import Message from './forum/message.js';
|
|
import MessageImage from './forum/message_image.js';
|
|
import MessageHistory from './forum/message_history.js';
|
|
import TitleHistory from './forum/title_history.js';
|
|
import ForumPermission from './forum/forum_permission.js';
|
|
import ForumUserPermission from './forum/forum_user_permission.js';
|
|
import ForumForumPermission from './forum/forum_forum_permission.js';
|
|
import Friendship from './community/friendship.js';
|
|
import FalukantUser from './falukant/data/user.js';
|
|
import RegionType from './falukant/type/region.js';
|
|
import RegionData from './falukant/data/region.js';
|
|
import FalukantCharacter from './falukant/data/character.js';
|
|
import FalukantPredefineFirstname from './falukant/predefine/firstname.js';
|
|
import FalukantPredefineLastname from './falukant/predefine/lastname.js';
|
|
import FalukantStock from './falukant/data/stock.js';
|
|
import FalukantStockType from './falukant/type/stock.js';
|
|
import Knowledge from './falukant/data/product_knowledge.js';
|
|
import ProductType from './falukant/type/product.js';
|
|
import TitleOfNobility from './falukant/type/title_of_nobility.js';
|
|
import TitleRequirement from './falukant/type/title_requirement.js';
|
|
import Branch from './falukant/data/branch.js';
|
|
import BranchType from './falukant/type/branch.js';
|
|
import Production from './falukant/data/production.js';
|
|
import Inventory from './falukant/data/inventory.js';
|
|
import BuyableStock from './falukant/data/buyable_stock.js';
|
|
import MoneyFlow from './falukant/log/moneyflow.js';
|
|
import Director from './falukant/data/director.js';
|
|
import DirectorProposal from './falukant/data/director_proposal.js';
|
|
import TownProductWorth from './falukant/data/town_product_worth.js';
|
|
import DayProduction from './falukant/log/dayproduction.js';
|
|
import DaySell from './falukant/log/daysell.js';
|
|
import MarriageProposal from './falukant/data/marriage_proposal.js';
|
|
import Notification from './falukant/log/notification.js';
|
|
import CharacterTrait from './falukant/type/character_trait.js';
|
|
import FalukantCharacterTrait from './falukant/data/falukant_character_trait.js';
|
|
import Mood from './falukant/type/mood.js';
|
|
import PromotionalGift from './falukant/type/promotional_gift.js';
|
|
import PromotionalGiftCharacterTrait from './falukant/predefine/promotional_gift_character_trait.js';
|
|
import PromotionalGiftMood from './falukant/predefine/promotional_gift_mood.js';
|
|
import RelationshipType from './falukant/type/relationship.js';
|
|
import Relationship from './falukant/data/relationship.js';
|
|
import PromotionalGiftLog from './falukant/log/promotional_gift.js';
|
|
import HouseType from './falukant/type/house.js';
|
|
import BuyableHouse from './falukant/data/buyable_house.js';
|
|
import UserHouse from './falukant/data/user_house.js';
|
|
import PartyType from './falukant/type/party.js';
|
|
import Party from './falukant/data/party.js';
|
|
import MusicType from './falukant/type/music.js';
|
|
import BanquetteType from './falukant/type/banquette.js';
|
|
import PartyInvitedNobility from './falukant/data/partyInvitedNobility.js';
|
|
import ChildRelation from './falukant/data/child_relation.js';
|
|
import Learning from './falukant/data/learning.js';
|
|
import LearnRecipient from './falukant/type/learn_recipient.js';
|
|
import Credit from './falukant/data/credit.js';
|
|
import DebtorsPrism from './falukant/data/debtors_prism.js';
|
|
import HealthActivity from './falukant/log/health_activity.js';
|
|
import Election from './falukant/data/election.js';
|
|
import ElectionResult from './falukant/data/election_result.js';
|
|
import Candidate from './falukant/data/candidate.js';
|
|
import Vote from './falukant/data/vote.js';
|
|
import PoliticalOfficeType from './falukant/type/political_office_type.js';
|
|
import PoliticalOffice from './falukant/data/political_office.js';
|
|
import PoliticalOfficeBenefit from './falukant/predefine/political_office_benefit.js';
|
|
import PoliticalOfficeBenefitType from './falukant/type/political_office_benefit_type.js';
|
|
import PoliticalOfficeRequirement from './falukant/predefine/political_office_prerequisite.js';
|
|
import PoliticalOfficePrerequisite from './falukant/predefine/political_office_prerequisite.js';
|
|
import PoliticalOfficeHistory from './falukant/log/political_office_history.js';
|
|
import ElectionHistory from './falukant/log/election_history.js';
|
|
import Underground from './falukant/data/underground.js';
|
|
import UndergroundType from './falukant/type/underground.js';
|
|
import Blog from './community/blog.js';
|
|
import BlogPost from './community/blog_post.js';
|
|
import Campaign from './match3/campaign.js';
|
|
import Match3Level from './match3/level.js';
|
|
import Objective from './match3/objective.js';
|
|
import UserProgress from './match3/userProgress.js';
|
|
import UserLevelProgress from './match3/userLevelProgress.js';
|
|
import TaxiGameState from './taxi/taxiGameState.js';
|
|
import TaxiLevelStats from './taxi/taxiLevelStats.js';
|
|
import TaxiMapType from './taxi/taxiMapType.js';
|
|
import TaxiMap from './taxi/taxiMap.js';
|
|
import TaxiMapTile from './taxi/taxiMapTile.js';
|
|
import TaxiMapTileHouse from './taxi/taxiMapTileHouse.js';
|
|
import TaxiStreetName from './taxi/taxiStreetName.js';
|
|
import TaxiMapTileStreet from './taxi/taxiMapTileStreet.js';
|
|
import TaxiHighscore from './minigames/taxiHighscore.js';
|
|
|
|
export default function setupAssociations() {
|
|
// RoomType 1:n Room
|
|
RoomType.hasMany(Room, { foreignKey: 'roomTypeId', as: 'rooms' });
|
|
Room.belongsTo(RoomType, { foreignKey: 'roomTypeId', as: 'roomType' });
|
|
// ChatUser <-> ChatRight n:m
|
|
ChatUser.belongsToMany(ChatRight, {
|
|
through: ChatUserRight,
|
|
foreignKey: 'chat_user_id',
|
|
otherKey: 'chat_right_id',
|
|
as: 'rights',
|
|
});
|
|
ChatRight.belongsToMany(ChatUser, {
|
|
through: ChatUserRight,
|
|
foreignKey: 'chat_right_id',
|
|
otherKey: 'chat_user_id',
|
|
as: 'users',
|
|
});
|
|
// ChatUser zu FalukantUser
|
|
ChatUser.belongsTo(FalukantUser, { foreignKey: 'falukant_user_id', as: 'falukantUser' });
|
|
FalukantUser.hasOne(ChatUser, { foreignKey: 'falukant_user_id', as: 'chatUser' });
|
|
// Chat Room associations
|
|
Room.belongsTo(User, { foreignKey: 'owner_id', as: 'owner' });
|
|
User.hasMany(Room, { foreignKey: 'owner_id', as: 'ownedRooms' });
|
|
|
|
Room.belongsTo(UserParamValue, { foreignKey: 'gender_restriction_id', as: 'genderRestriction' });
|
|
UserParamValue.hasMany(Room, { foreignKey: 'gender_restriction_id', as: 'roomsWithGenderRestriction' });
|
|
// UserParam related associations
|
|
SettingsType.hasMany(UserParamType, { foreignKey: 'settingsId', as: 'user_param_types' });
|
|
UserParamType.belongsTo(SettingsType, { foreignKey: 'settingsId', as: 'settings_type' });
|
|
|
|
UserParamType.hasMany(UserParam, { foreignKey: 'paramTypeId', as: 'user_params' });
|
|
UserParam.belongsTo(UserParamType, { foreignKey: 'paramTypeId', as: 'paramType' });
|
|
|
|
User.hasMany(UserParam, { foreignKey: 'userId', as: 'user_params' });
|
|
UserParam.belongsTo(User, { foreignKey: 'userId', as: 'user' });
|
|
|
|
UserParamValue.belongsTo(UserParamType, { foreignKey: 'userParamTypeId', as: 'user_param_value_type' });
|
|
UserParamType.hasMany(UserParamValue, { foreignKey: 'userParamTypeId', as: 'user_param_type_value' });
|
|
|
|
UserRight.belongsTo(User, { foreignKey: 'userId', as: 'user_with_rights' });
|
|
UserRight.belongsTo(UserRightType, { foreignKey: 'rightTypeId', as: 'rightType' });
|
|
UserRightType.hasMany(UserRight, { foreignKey: 'rightTypeId', as: 'user_rights' });
|
|
|
|
UserParam.hasMany(UserParamVisibility, { foreignKey: 'param_id', as: 'param_visibilities' });
|
|
UserParamVisibility.belongsTo(UserParam, { foreignKey: 'param_id', as: 'param' });
|
|
|
|
UserParamVisibility.belongsTo(UserParamVisibilityType, { foreignKey: 'visibility', as: 'visibility_type' });
|
|
UserParamVisibilityType.hasMany(UserParamVisibility, { foreignKey: 'visibility', as: 'user_param_visibilities' });
|
|
|
|
// Interest related associations
|
|
InterestType.hasMany(InterestTranslationType, { foreignKey: 'interestsId', as: 'interest_translations' });
|
|
InterestTranslationType.belongsTo(InterestType, { foreignKey: 'interestsId', as: 'interest_translations' });
|
|
|
|
InterestType.hasMany(Interest, { foreignKey: 'userinterestId', as: 'user_interest_type' });
|
|
User.hasMany(Interest, { foreignKey: 'userId', as: 'user_interests' });
|
|
Interest.belongsTo(InterestType, { foreignKey: 'userinterestId', as: 'interest_type' });
|
|
Interest.belongsTo(User, { foreignKey: 'userId', as: 'interest_owner' });
|
|
|
|
// Folder and Image related associations
|
|
Folder.belongsTo(User, { foreignKey: 'userId' });
|
|
User.hasMany(Folder, { foreignKey: 'userId' });
|
|
|
|
Folder.belongsTo(Folder, { foreignKey: 'parentId', as: 'parent' });
|
|
Folder.hasMany(Folder, { foreignKey: 'parentId', as: 'children' });
|
|
|
|
Image.belongsTo(Folder, { foreignKey: 'folderId' });
|
|
Folder.hasMany(Image, { foreignKey: 'folderId' });
|
|
|
|
Image.belongsTo(User, { foreignKey: 'userId' });
|
|
User.hasMany(Image, { foreignKey: 'userId' });
|
|
|
|
// Image visibility associations
|
|
Folder.belongsToMany(ImageVisibilityType, {
|
|
through: FolderImageVisibility,
|
|
foreignKey: 'folderId',
|
|
otherKey: 'visibilityTypeId'
|
|
});
|
|
ImageVisibilityType.belongsToMany(Folder, {
|
|
through: FolderImageVisibility,
|
|
foreignKey: 'visibilityTypeId',
|
|
otherKey: 'folderId'
|
|
});
|
|
|
|
Image.belongsToMany(ImageVisibilityType, {
|
|
through: ImageImageVisibility,
|
|
foreignKey: 'imageId',
|
|
otherKey: 'visibilityTypeId'
|
|
});
|
|
ImageVisibilityType.belongsToMany(Image, {
|
|
through: ImageImageVisibility,
|
|
foreignKey: 'visibilityTypeId',
|
|
otherKey: 'imageId'
|
|
});
|
|
|
|
Folder.belongsToMany(ImageVisibilityUser, {
|
|
through: FolderVisibilityUser,
|
|
foreignKey: 'folderId',
|
|
otherKey: 'visibilityUserId'
|
|
});
|
|
ImageVisibilityUser.belongsToMany(Folder, {
|
|
through: FolderVisibilityUser,
|
|
foreignKey: 'visibilityUserId',
|
|
otherKey: 'folderId'
|
|
});
|
|
|
|
// Guestbook related associations
|
|
User.hasMany(GuestbookEntry, { foreignKey: 'recipientId', as: 'receivedEntries' });
|
|
User.hasMany(GuestbookEntry, { foreignKey: 'senderId', as: 'sentEntries' });
|
|
GuestbookEntry.belongsTo(User, { foreignKey: 'recipientId', as: 'recipient' });
|
|
GuestbookEntry.belongsTo(User, { foreignKey: 'senderId', as: 'sender' });
|
|
|
|
// Forum related associations
|
|
Forum.hasMany(Title, { foreignKey: 'forumId' });
|
|
Title.belongsTo(Forum, { foreignKey: 'forumId' });
|
|
|
|
Title.belongsTo(User, { foreignKey: 'createdBy', as: 'createdByUser' });
|
|
User.hasMany(Title, { foreignKey: 'createdBy', as: 'titles' });
|
|
|
|
Title.hasMany(Message, { foreignKey: 'titleId', as: 'messages' });
|
|
Message.belongsTo(Title, { foreignKey: 'titleId', as: 'title' });
|
|
|
|
Message.belongsTo(User, { foreignKey: 'createdBy', as: 'lastMessageUser' });
|
|
User.hasMany(Message, { foreignKey: 'createdBy', as: 'userMessages' });
|
|
|
|
Message.hasMany(MessageImage, { foreignKey: 'messageId' });
|
|
MessageImage.belongsTo(Message, { foreignKey: 'messageId' });
|
|
|
|
Message.hasMany(MessageHistory, { foreignKey: 'messageId' });
|
|
MessageHistory.belongsTo(Message, { foreignKey: 'messageId' });
|
|
|
|
Title.hasMany(TitleHistory, { foreignKey: 'titleId' });
|
|
TitleHistory.belongsTo(Title, { foreignKey: 'titleId' });
|
|
|
|
// Forum permissions associations
|
|
Forum.hasMany(ForumUserPermission, { foreignKey: 'forumId', as: 'userPermissions' });
|
|
ForumUserPermission.belongsTo(Forum, { foreignKey: 'forumId' });
|
|
|
|
User.hasMany(ForumUserPermission, { foreignKey: 'userId', as: 'userPermissions' });
|
|
ForumUserPermission.belongsTo(User, { foreignKey: 'userId' });
|
|
|
|
Forum.belongsToMany(ForumPermission, {
|
|
through: ForumForumPermission,
|
|
foreignKey: 'forumId',
|
|
as: 'associatedPermissions'
|
|
});
|
|
|
|
ForumPermission.belongsToMany(Forum, {
|
|
through: ForumForumPermission,
|
|
foreignKey: 'permissionId',
|
|
as: 'forums'
|
|
});
|
|
|
|
ForumPermission.hasMany(ForumUserPermission, { foreignKey: 'permissionId' });
|
|
ForumUserPermission.belongsTo(ForumPermission, { foreignKey: 'permissionId' });
|
|
|
|
Friendship.belongsTo(User, { foreignKey: 'user1Id', as: 'friendSender' });
|
|
Friendship.belongsTo(User, { foreignKey: 'user2Id', as: 'friendReceiver' });
|
|
User.hasMany(Friendship, { foreignKey: 'user1Id', as: 'friendSender' });
|
|
User.hasMany(Friendship, { foreignKey: 'user2Id', as: 'friendReceiver' });
|
|
|
|
User.hasMany(FalukantUser, { foreignKey: 'userId', as: 'falukantData' });
|
|
FalukantUser.belongsTo(User, { foreignKey: 'userId', as: 'user' });
|
|
|
|
RegionType.hasMany(RegionType, { foreignKey: 'parentId', as: 'children' });
|
|
RegionType.belongsTo(RegionType, { foreignKey: 'parentId', as: 'parent' });
|
|
|
|
RegionData.hasMany(RegionData, { foreignKey: 'parentId', as: 'children' });
|
|
RegionData.belongsTo(RegionData, { foreignKey: 'parentId', as: 'parent' });
|
|
|
|
RegionData.belongsTo(RegionType, { foreignKey: 'regionTypeId', as: 'regionType' });
|
|
RegionType.hasMany(RegionData, { foreignKey: 'regionTypeId', as: 'regions' });
|
|
|
|
FalukantUser.belongsTo(RegionData, { foreignKey: 'mainBranchRegionId', as: 'mainBranchRegion' });
|
|
RegionData.hasMany(FalukantUser, { foreignKey: 'mainBranchRegionId', as: 'users' });
|
|
|
|
FalukantCharacter.belongsTo(FalukantUser, { foreignKey: 'userId', as: 'user' });
|
|
FalukantUser.hasOne(FalukantCharacter, { foreignKey: 'userId', as: 'character' });
|
|
|
|
FalukantCharacter.belongsTo(FalukantPredefineFirstname, { foreignKey: 'firstName', as: 'definedFirstName' });
|
|
FalukantPredefineFirstname.hasMany(FalukantCharacter, { foreignKey: 'firstName', as: 'charactersWithFirstName' });
|
|
|
|
FalukantCharacter.belongsTo(FalukantPredefineLastname, { foreignKey: 'lastName', as: 'definedLastName' });
|
|
FalukantPredefineLastname.hasMany(FalukantCharacter, { foreignKey: 'lastName', as: 'charactersWithLastName' });
|
|
|
|
FalukantCharacter.belongsTo(TitleOfNobility, { foreignKey: 'titleOfNobility', as: 'nobleTitle' });
|
|
TitleOfNobility.hasMany(FalukantCharacter, { foreignKey: 'titleOfNobility', as: 'charactersWithNobleTitle' });
|
|
|
|
FalukantCharacter.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
|
|
RegionData.hasMany(FalukantCharacter, { foreignKey: 'regionId', as: 'charactersInRegion' });
|
|
|
|
FalukantStock.belongsTo(FalukantStockType, { foreignKey: 'stockTypeId', as: 'stockType' });
|
|
FalukantStockType.hasMany(FalukantStock, { foreignKey: 'stockTypeId', as: 'stocks' });
|
|
|
|
Knowledge.belongsTo(ProductType, { foreignKey: 'productId', as: 'productType' });
|
|
ProductType.hasMany(Knowledge, { foreignKey: 'productId', as: 'knowledges' });
|
|
|
|
Knowledge.belongsTo(FalukantCharacter, { foreignKey: 'characterId', as: 'character' });
|
|
FalukantCharacter.hasMany(Knowledge, { foreignKey: 'characterId', as: 'knowledges' });
|
|
|
|
TitleRequirement.belongsTo(TitleOfNobility, { foreignKey: 'titleId', as: 'title' });
|
|
TitleOfNobility.hasMany(TitleRequirement, { foreignKey: 'titleId', as: 'requirements' });
|
|
|
|
Branch.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
|
|
RegionData.hasMany(Branch, { foreignKey: 'regionId', as: 'branches' });
|
|
|
|
Branch.belongsTo(FalukantUser, { foreignKey: 'falukantUserId', as: 'user' });
|
|
FalukantUser.hasMany(Branch, { foreignKey: 'falukantUserId', as: 'branches' });
|
|
|
|
Branch.belongsTo(BranchType, { foreignKey: 'branchTypeId', as: 'branchType' });
|
|
BranchType.hasMany(Branch, { foreignKey: 'branchTypeId', as: 'branches' });
|
|
|
|
Production.belongsTo(Branch, { foreignKey: 'branchId', as: 'branch' });
|
|
Branch.hasMany(Production, { foreignKey: 'branchId', as: 'productions' });
|
|
|
|
Production.belongsTo(ProductType, { foreignKey: 'productId', as: 'productType' });
|
|
ProductType.hasMany(Production, { foreignKey: 'productId', as: 'productions' });
|
|
|
|
Inventory.belongsTo(FalukantStock, { foreignKey: 'stockId', as: 'stock' });
|
|
FalukantStock.hasMany(Inventory, { foreignKey: 'stockId', as: 'inventories' });
|
|
|
|
Inventory.belongsTo(ProductType, { foreignKey: 'productId', as: 'productType' });
|
|
ProductType.hasMany(Inventory, { foreignKey: 'productId', as: 'inventories' });
|
|
|
|
BuyableStock.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
|
|
RegionData.hasMany(BuyableStock, { foreignKey: 'regionId', as: 'buyableStocks' });
|
|
|
|
Branch.hasMany(FalukantStock, { foreignKey: 'branchId', as: 'stocks' });
|
|
FalukantStock.belongsTo(Branch, { foreignKey: 'branchId', as: 'branch' });
|
|
|
|
MoneyFlow.belongsTo(FalukantUser, { foreignKey: 'falukantUserId', as: 'user' });
|
|
FalukantUser.hasMany(MoneyFlow, { foreignKey: 'falukantUserId', as: 'flows' });
|
|
|
|
BuyableStock.belongsTo(FalukantStockType, { foreignKey: 'stockTypeId', as: 'stockType' });
|
|
FalukantStockType.hasMany(BuyableStock, { foreignKey: 'stockTypeId', as: 'buyableStocks' });
|
|
|
|
Director.belongsTo(FalukantUser, { foreignKey: 'employerUserId', as: 'user' });
|
|
FalukantUser.hasMany(Director, { foreignKey: 'employerUserId', as: 'directors' });
|
|
|
|
Director.belongsTo(FalukantCharacter, { foreignKey: 'directorCharacterId', as: 'character' });
|
|
FalukantCharacter.hasMany(Director, { foreignKey: 'directorCharacterId', as: 'directors' });
|
|
|
|
DirectorProposal.belongsTo(FalukantUser, { foreignKey: 'employerUserId', as: 'user' });
|
|
FalukantUser.hasMany(DirectorProposal, { foreignKey: 'employerUserId', as: 'directorProposals' });
|
|
|
|
DirectorProposal.belongsTo(FalukantCharacter, { foreignKey: 'directorCharacterId', as: 'character' });
|
|
FalukantCharacter.hasMany(DirectorProposal, { foreignKey: 'directorCharacterId', as: 'directorProposals' });
|
|
|
|
TownProductWorth.belongsTo(ProductType, { foreignKey: 'productId', as: 'productType' });
|
|
ProductType.hasMany(TownProductWorth, { foreignKey: 'productId', as: 'townProductWorths' });
|
|
|
|
TownProductWorth.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
|
|
RegionData.hasMany(TownProductWorth, { foreignKey: 'regionId', as: 'townProductWorths' });
|
|
|
|
DayProduction.belongsTo(ProductType, { foreignKey: 'productId', as: 'productType' });
|
|
ProductType.hasMany(DayProduction, { foreignKey: 'productId', as: 'dayProductions' });
|
|
|
|
DayProduction.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
|
|
RegionData.hasMany(DayProduction, { foreignKey: 'regionId', as: 'dayProductions' });
|
|
|
|
DayProduction.belongsTo(FalukantUser, { foreignKey: 'producerId', as: 'user' });
|
|
FalukantUser.hasMany(DayProduction, { foreignKey: 'producerId', as: 'dayProductions' });
|
|
|
|
DaySell.belongsTo(ProductType, { foreignKey: 'productId', as: 'productType' });
|
|
ProductType.hasMany(DaySell, { foreignKey: 'productId', as: 'daySells' });
|
|
|
|
DaySell.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
|
|
RegionData.hasMany(DaySell, { foreignKey: 'regionId', as: 'daySells' });
|
|
|
|
DaySell.belongsTo(FalukantUser, { foreignKey: 'sellerId', as: 'user' });
|
|
FalukantUser.hasMany(DaySell, { foreignKey: 'sellerId', as: 'daySells' });
|
|
|
|
Notification.belongsTo(FalukantUser, { foreignKey: 'userId', as: 'user' });
|
|
FalukantUser.hasMany(Notification, { foreignKey: 'userId', as: 'notifications' });
|
|
|
|
MarriageProposal.belongsTo(FalukantCharacter, { foreignKey: 'requesterCharacterId', as: 'requesterCharacter', });
|
|
FalukantCharacter.hasMany(MarriageProposal, { foreignKey: 'requesterCharacterId', as: 'initiatedProposals' });
|
|
|
|
MarriageProposal.belongsTo(FalukantCharacter, { foreignKey: 'proposedCharacterId', as: 'proposedCharacter', });
|
|
FalukantCharacter.hasMany(MarriageProposal, { foreignKey: 'proposedCharacterId', as: 'receivedProposals' });
|
|
|
|
FalukantCharacter.belongsToMany(CharacterTrait, { through: FalukantCharacterTrait, foreignKey: 'character_id', as: 'traits', });
|
|
CharacterTrait.belongsToMany(FalukantCharacter, { through: FalukantCharacterTrait, foreignKey: 'trait_id', as: 'characters', });
|
|
|
|
Mood.hasMany(FalukantCharacter, { foreignKey: 'mood_id', as: 'moods' });
|
|
FalukantCharacter.belongsTo(Mood, { foreignKey: 'mood_id', as: 'mood' });
|
|
|
|
PromotionalGift.belongsToMany(CharacterTrait, { through: PromotionalGiftCharacterTrait, foreignKey: 'gift_id', as: 'traits', });
|
|
CharacterTrait.belongsToMany(PromotionalGift, { through: PromotionalGiftCharacterTrait, foreignKey: 'trait_id', as: 'gifts', });
|
|
|
|
PromotionalGift.belongsToMany(Mood, { through: PromotionalGiftMood, foreignKey: 'gift_id', as: 'moods', });
|
|
Mood.belongsToMany(PromotionalGift, { through: PromotionalGiftMood, foreignKey: 'mood_id', as: 'gifts', });
|
|
|
|
Relationship.belongsTo(RelationshipType, { foreignKey: 'relationshipTypeId', as: 'relationshipType' });
|
|
RelationshipType.hasMany(Relationship, { foreignKey: 'relationshipTypeId', as: 'relationships' });
|
|
|
|
Relationship.belongsTo(FalukantCharacter, { foreignKey: 'character1Id', as: 'character1', });
|
|
Relationship.belongsTo(FalukantCharacter, { foreignKey: 'character2Id', as: 'character2', });
|
|
FalukantCharacter.hasMany(Relationship, { foreignKey: 'character1Id', as: 'relationshipsAsCharacter1', });
|
|
FalukantCharacter.hasMany(Relationship, { foreignKey: 'character2Id', as: 'relationshipsAsCharacter2', });
|
|
|
|
PromotionalGiftLog.belongsTo(PromotionalGift, { foreignKey: 'giftId', as: 'gift' });
|
|
PromotionalGift.hasMany(PromotionalGiftLog, { foreignKey: 'giftId', as: 'logs' });
|
|
|
|
PromotionalGiftLog.belongsTo(FalukantCharacter, { foreignKey: 'senderCharacterId', as: 'character' });
|
|
FalukantCharacter.hasMany(PromotionalGiftLog, { foreignKey: 'senderCharacterId', as: 'logs' });
|
|
|
|
PromotionalGiftLog.belongsTo(FalukantCharacter, { foreignKey: 'recipientCharacterId', as: 'recipient' });
|
|
FalukantCharacter.hasMany(PromotionalGiftLog, { foreignKey: 'recipientCharacterId', as: 'giftlogs' });
|
|
|
|
PromotionalGift.hasMany(PromotionalGiftCharacterTrait, { foreignKey: 'gift_id', as: 'characterTraits' });
|
|
PromotionalGift.hasMany(PromotionalGiftMood, { foreignKey: 'gift_id', as: 'promotionalgiftmoods' });
|
|
|
|
PromotionalGiftCharacterTrait.belongsTo(PromotionalGift, { foreignKey: 'gift_id', as: 'promotionalgiftcharactertrait' });
|
|
PromotionalGiftMood.belongsTo(PromotionalGift, { foreignKey: 'gift_id', as: 'promotionalgiftcharactermood' });
|
|
|
|
HouseType.hasMany(BuyableHouse, { foreignKey: 'houseTypeId', as: 'buyableHouses' });
|
|
BuyableHouse.belongsTo(HouseType, { foreignKey: 'houseTypeId', as: 'houseType' });
|
|
|
|
HouseType.hasMany(UserHouse, { foreignKey: 'houseTypeId', as: 'userHouses' });
|
|
UserHouse.belongsTo(HouseType, { foreignKey: 'houseTypeId', as: 'houseType' });
|
|
|
|
FalukantUser.hasOne(UserHouse, { foreignKey: 'userId', as: 'userHouse' });
|
|
UserHouse.belongsTo(FalukantUser, { foreignKey: 'userId', as: 'houseUser' });
|
|
|
|
TitleOfNobility.hasMany(HouseType, { foreignKey: 'minimumNobleTitle', as: 'houseTypes' });
|
|
HouseType.belongsTo(TitleOfNobility, { foreignKey: 'minimumNobleTitle', as: 'titleOfNobility' });
|
|
|
|
PartyType.hasMany(Party, { foreignKey: 'partyTypeId', as: 'parties' });
|
|
Party.belongsTo(PartyType, { foreignKey: 'partyTypeId', as: 'partyType' });
|
|
|
|
MusicType.hasMany(Party, { foreignKey: 'musicTypeId', as: 'parties' });
|
|
Party.belongsTo(MusicType, { foreignKey: 'musicTypeId', as: 'musicType' });
|
|
|
|
BanquetteType.hasMany(Party, { foreignKey: 'banquetteTypeId', as: 'parties' });
|
|
Party.belongsTo(BanquetteType, { foreignKey: 'banquetteTypeId', as: 'banquetteType' });
|
|
|
|
FalukantUser.hasMany(Party, { foreignKey: 'falukantUserId', as: 'parties' });
|
|
Party.belongsTo(FalukantUser, { foreignKey: 'falukantUserId', as: 'partyUser' });
|
|
|
|
Party.belongsToMany(TitleOfNobility, {
|
|
through: PartyInvitedNobility,
|
|
foreignKey: 'party_id',
|
|
otherKey: 'title_of_nobility_id',
|
|
as: 'invitedNobilities',
|
|
});
|
|
TitleOfNobility.belongsToMany(Party, {
|
|
through: PartyInvitedNobility,
|
|
foreignKey: 'title_of_nobility_id',
|
|
otherKey: 'party_id',
|
|
as: 'partiesInvitedTo',
|
|
});
|
|
|
|
ChildRelation.belongsTo(FalukantCharacter, {
|
|
foreignKey: 'fatherCharacterId',
|
|
as: 'father'
|
|
});
|
|
FalukantCharacter.hasMany(ChildRelation, {
|
|
foreignKey: 'fatherCharacterId',
|
|
as: 'childrenFather'
|
|
});
|
|
|
|
ChildRelation.belongsTo(FalukantCharacter, {
|
|
foreignKey: 'motherCharacterId',
|
|
as: 'mother'
|
|
});
|
|
FalukantCharacter.hasMany(ChildRelation, {
|
|
foreignKey: 'motherCharacterId',
|
|
as: 'childrenMother'
|
|
});
|
|
|
|
ChildRelation.belongsTo(FalukantCharacter, {
|
|
foreignKey: 'childCharacterId',
|
|
as: 'child'
|
|
});
|
|
FalukantCharacter.hasMany(ChildRelation, {
|
|
foreignKey: 'childCharacterId',
|
|
as: 'parentRelations'
|
|
});
|
|
|
|
Learning.belongsTo(LearnRecipient, {
|
|
foreignKey: 'learningRecipientId',
|
|
as: 'recipient'
|
|
}
|
|
);
|
|
|
|
LearnRecipient.hasMany(Learning, {
|
|
foreignKey: 'learningRecipientId',
|
|
as: 'learnings'
|
|
});
|
|
|
|
Learning.belongsTo(FalukantUser, {
|
|
foreignKey: 'associatedFalukantUserId',
|
|
as: 'learner'
|
|
}
|
|
);
|
|
|
|
FalukantUser.hasMany(Learning, {
|
|
foreignKey: 'associatedFalukantUserId',
|
|
as: 'learnings'
|
|
});
|
|
|
|
Learning.belongsTo(ProductType, {
|
|
foreignKey: 'productId',
|
|
as: 'productType'
|
|
});
|
|
|
|
ProductType.hasMany(Learning, {
|
|
foreignKey: 'productId',
|
|
as: 'learnings'
|
|
});
|
|
|
|
Learning.belongsTo(FalukantCharacter, {
|
|
foreignKey: 'associatedLearningCharacterId',
|
|
as: 'learningCharacter'
|
|
});
|
|
|
|
FalukantCharacter.hasMany(Learning, {
|
|
foreignKey: 'associatedLearningCharacterId',
|
|
as: 'learningsCharacter'
|
|
});
|
|
|
|
FalukantUser.hasMany(Credit, {
|
|
foreignKey: 'falukantUserId',
|
|
as: 'credits'
|
|
});
|
|
Credit.belongsTo(FalukantUser, {
|
|
foreignKey: 'falukantUserId',
|
|
as: 'user'
|
|
});
|
|
|
|
FalukantCharacter.hasMany(DebtorsPrism, {
|
|
foreignKey: 'character_id',
|
|
as: 'debtorsPrisms'
|
|
});
|
|
DebtorsPrism.belongsTo(FalukantCharacter, {
|
|
foreignKey: 'character_id',
|
|
as: 'character'
|
|
});
|
|
|
|
HealthActivity.belongsTo(FalukantCharacter, {
|
|
foreignKey: 'character_id',
|
|
as: 'character'
|
|
});
|
|
FalukantCharacter.hasMany(HealthActivity, {
|
|
foreignKey: 'character_id',
|
|
as: 'healthActivities'
|
|
});
|
|
|
|
// — Political Offices —
|
|
|
|
// predefine requirements for office
|
|
PoliticalOfficeRequirement.belongsTo(PoliticalOfficeType, {
|
|
foreignKey: 'officeTypeId',
|
|
as: 'officeType'
|
|
});
|
|
PoliticalOfficeType.hasMany(PoliticalOfficeRequirement, {
|
|
foreignKey: 'officeTypeId',
|
|
as: 'requirements'
|
|
});
|
|
|
|
// predefine benefits for office
|
|
PoliticalOfficeBenefit.belongsTo(
|
|
PoliticalOfficeBenefitType,
|
|
{ foreignKey: 'benefitTypeId', as: 'benefitDefinition' }
|
|
);
|
|
PoliticalOfficeBenefitType.hasMany(
|
|
PoliticalOfficeBenefit,
|
|
{ foreignKey: 'benefitTypeId', as: 'benefitDefinitions' }
|
|
);
|
|
|
|
// tie benefits back to office type
|
|
PoliticalOfficeBenefit.belongsTo(PoliticalOfficeType, {
|
|
foreignKey: 'officeTypeId',
|
|
as: 'officeType'
|
|
});
|
|
PoliticalOfficeType.hasMany(PoliticalOfficeBenefit, {
|
|
foreignKey: 'officeTypeId',
|
|
as: 'benefits'
|
|
});
|
|
|
|
// actual office holdings
|
|
PoliticalOffice.belongsTo(PoliticalOfficeType, {
|
|
foreignKey: 'officeTypeId',
|
|
as: 'type'
|
|
});
|
|
PoliticalOfficeType.hasMany(PoliticalOffice, {
|
|
foreignKey: 'officeTypeId',
|
|
as: 'offices'
|
|
});
|
|
|
|
PoliticalOffice.belongsTo(FalukantCharacter, {
|
|
foreignKey: 'characterId',
|
|
as: 'holder'
|
|
});
|
|
FalukantCharacter.hasOne(PoliticalOffice, {
|
|
foreignKey: 'characterId',
|
|
as: 'heldOffice'
|
|
});
|
|
|
|
// elections
|
|
Election.belongsTo(PoliticalOfficeType, {
|
|
foreignKey: 'officeTypeId',
|
|
as: 'officeType'
|
|
});
|
|
PoliticalOfficeType.hasMany(Election, {
|
|
foreignKey: 'officeTypeId',
|
|
as: 'elections'
|
|
});
|
|
|
|
Election.belongsTo(RegionData, {
|
|
foreignKey: 'regionId',
|
|
as: 'region'
|
|
});
|
|
|
|
RegionData.hasMany(Election, {
|
|
foreignKey: 'regionId',
|
|
as: 'elections'
|
|
});
|
|
|
|
// candidates in an election
|
|
Candidate.belongsTo(Election, {
|
|
foreignKey: 'electionId',
|
|
as: 'election'
|
|
});
|
|
Election.hasMany(Candidate, {
|
|
foreignKey: 'electionId',
|
|
as: 'candidates'
|
|
});
|
|
|
|
Candidate.belongsTo(FalukantCharacter, {
|
|
foreignKey: 'characterId',
|
|
as: 'character'
|
|
});
|
|
FalukantCharacter.hasMany(Candidate, {
|
|
foreignKey: 'characterId',
|
|
as: 'candidacies'
|
|
});
|
|
|
|
// votes cast
|
|
Vote.belongsTo(Election, {
|
|
foreignKey: 'electionId',
|
|
as: 'election'
|
|
});
|
|
Election.hasMany(Vote, {
|
|
foreignKey: 'electionId',
|
|
as: 'votes'
|
|
});
|
|
|
|
Vote.belongsTo(Candidate, {
|
|
foreignKey: 'candidateId',
|
|
as: 'candidate'
|
|
});
|
|
Candidate.hasMany(Vote, {
|
|
foreignKey: 'candidateId',
|
|
as: 'votes'
|
|
});
|
|
|
|
Vote.belongsTo(FalukantCharacter, {
|
|
foreignKey: 'voterCharacterId',
|
|
as: 'voter'
|
|
});
|
|
FalukantCharacter.hasMany(Vote, {
|
|
foreignKey: 'voterCharacterId',
|
|
as: 'votesCast'
|
|
});
|
|
|
|
// election results
|
|
ElectionResult.belongsTo(Election, {
|
|
foreignKey: 'electionId',
|
|
as: 'election'
|
|
});
|
|
Election.hasMany(ElectionResult, {
|
|
foreignKey: 'electionId',
|
|
as: 'results'
|
|
});
|
|
|
|
ElectionResult.belongsTo(Candidate, {
|
|
foreignKey: 'candidateId',
|
|
as: 'candidate'
|
|
});
|
|
Candidate.hasMany(ElectionResult, {
|
|
foreignKey: 'candidateId',
|
|
as: 'results'
|
|
});
|
|
|
|
PoliticalOffice.belongsTo(RegionData, {
|
|
foreignKey: 'regionId',
|
|
as: 'region'
|
|
});
|
|
RegionData.hasMany(PoliticalOffice, {
|
|
foreignKey: 'regionId',
|
|
as: 'offices'
|
|
});
|
|
|
|
PoliticalOfficePrerequisite.belongsTo(PoliticalOfficeType, {
|
|
foreignKey: 'office_type_id',
|
|
as: 'officeTypePrerequisite',
|
|
});
|
|
|
|
PoliticalOfficeType.hasMany(PoliticalOfficePrerequisite, {
|
|
foreignKey: 'office_type_id',
|
|
as: 'prerequisites',
|
|
});
|
|
|
|
PoliticalOfficeHistory.belongsTo(PoliticalOfficeType, {
|
|
foreignKey: 'officeTypeId',
|
|
as: 'officeTypeHistory',
|
|
});
|
|
|
|
PoliticalOfficeType.hasMany(PoliticalOfficeHistory, {
|
|
foreignKey: 'officeTypeId',
|
|
as: 'history',
|
|
});
|
|
|
|
FalukantCharacter.hasMany(PoliticalOfficeHistory, {
|
|
foreignKey: 'characterId',
|
|
as: 'officeHistories',
|
|
});
|
|
PoliticalOfficeHistory.belongsTo(FalukantCharacter, {
|
|
foreignKey: 'characterId',
|
|
as: 'character',
|
|
});
|
|
|
|
ElectionHistory.belongsTo(PoliticalOfficeType, {
|
|
foreignKey: 'officeTypeId',
|
|
as: 'officeTypeHistory',
|
|
});
|
|
|
|
PoliticalOfficeType.hasMany(ElectionHistory, {
|
|
foreignKey: 'officeTypeId',
|
|
as: 'electionHistory',
|
|
}
|
|
);
|
|
|
|
Underground.belongsTo(UndergroundType, {
|
|
foreignKey: 'undergroundTypeId',
|
|
as: 'undergroundType'
|
|
});
|
|
UndergroundType.hasMany(Underground, {
|
|
foreignKey: 'undergroundTypeId',
|
|
as: 'undergrounds'
|
|
});
|
|
|
|
// 2) Täter (performer)
|
|
Underground.belongsTo(FalukantCharacter, {
|
|
foreignKey: 'performerId',
|
|
as: 'performer'
|
|
});
|
|
FalukantCharacter.hasMany(Underground, {
|
|
foreignKey: 'performerId',
|
|
as: 'performedUndergrounds'
|
|
});
|
|
|
|
// 3) Opfer (victim)
|
|
Underground.belongsTo(FalukantCharacter, {
|
|
foreignKey: 'victimId',
|
|
as: 'victim'
|
|
});
|
|
FalukantCharacter.hasMany(Underground, {
|
|
foreignKey: 'victimId',
|
|
as: 'victimUndergrounds'
|
|
});
|
|
|
|
// Blog associations
|
|
Blog.belongsTo(User, { foreignKey: 'user_id', as: 'owner' });
|
|
User.hasMany(Blog, { foreignKey: 'user_id', as: 'blogs' });
|
|
BlogPost.belongsTo(Blog, { foreignKey: 'blog_id', as: 'blog' });
|
|
Blog.hasMany(BlogPost, { foreignKey: 'blog_id', as: 'posts' });
|
|
BlogPost.belongsTo(User, { foreignKey: 'user_id', as: 'author' });
|
|
User.hasMany(BlogPost, { foreignKey: 'user_id', as: 'blogPosts' });
|
|
|
|
// Match3 Campaign & Levels
|
|
Campaign.hasMany(Match3Level, { foreignKey: 'campaignId', as: 'levels' });
|
|
Match3Level.belongsTo(Campaign, { foreignKey: 'campaignId', as: 'campaign' });
|
|
Match3Level.hasMany(Objective, { foreignKey: 'levelId', as: 'objectives' });
|
|
Objective.belongsTo(Match3Level, { foreignKey: 'levelId', as: 'level' });
|
|
// User progress tracking
|
|
Campaign.hasMany(UserProgress, { foreignKey: 'campaignId', as: 'userProgressEntries' });
|
|
UserProgress.belongsTo(Campaign, { foreignKey: 'campaignId', as: 'campaign' });
|
|
UserProgress.hasMany(UserLevelProgress, { foreignKey: 'userProgressId', as: 'levelProgress' });
|
|
UserLevelProgress.belongsTo(UserProgress, { foreignKey: 'userProgressId', as: 'userProgress' });
|
|
Match3Level.hasMany(UserLevelProgress, { foreignKey: 'levelId', as: 'userLevelProgress' });
|
|
UserLevelProgress.belongsTo(Match3Level, { foreignKey: 'levelId', as: 'level' });
|
|
|
|
// Taxi Game associations
|
|
TaxiGameState.belongsTo(User, { foreignKey: 'userId', as: 'user' });
|
|
User.hasOne(TaxiGameState, { foreignKey: 'userId', as: 'taxiGameState' });
|
|
|
|
TaxiLevelStats.belongsTo(User, { foreignKey: 'userId', as: 'user' });
|
|
User.hasMany(TaxiLevelStats, { foreignKey: 'userId', as: 'taxiLevelStats' });
|
|
|
|
// Taxi Map associations
|
|
TaxiMap.belongsTo(TaxiMapType, { foreignKey: 'mapTypeId', as: 'mapType' });
|
|
TaxiMapType.hasMany(TaxiMap, { foreignKey: 'mapTypeId', as: 'maps' });
|
|
|
|
// Tiles
|
|
TaxiMap.hasMany(TaxiMapTile, { foreignKey: 'mapId', as: 'tiles' });
|
|
TaxiMapTile.belongsTo(TaxiMap, { foreignKey: 'mapId', as: 'map' });
|
|
|
|
// Street name models
|
|
TaxiMapTileStreet.belongsTo(TaxiMap, { foreignKey: 'map_id', as: 'map' });
|
|
TaxiMap.hasMany(TaxiMapTileStreet, { foreignKey: 'map_id', as: 'tileStreets' });
|
|
|
|
TaxiMapTileStreet.belongsTo(TaxiStreetName, { foreignKey: 'street_name_h_id', as: 'streetNameH' });
|
|
TaxiMapTileStreet.belongsTo(TaxiStreetName, { foreignKey: 'street_name_v_id', as: 'streetNameV' });
|
|
|
|
// Houses per tile (one row per corner)
|
|
TaxiMap.hasMany(TaxiMapTileHouse, { foreignKey: 'map_id', as: 'tileHouses' });
|
|
TaxiMapTileHouse.belongsTo(TaxiMap, { foreignKey: 'map_id', as: 'map' });
|
|
|
|
// Taxi Highscore associations
|
|
TaxiHighscore.belongsTo(User, { foreignKey: 'userId', as: 'user' });
|
|
User.hasMany(TaxiHighscore, { foreignKey: 'userId', as: 'taxiHighscores' });
|
|
|
|
TaxiHighscore.belongsTo(TaxiMap, { foreignKey: 'mapId', as: 'map' });
|
|
TaxiMap.hasMany(TaxiHighscore, { foreignKey: 'mapId', as: 'highscores' });
|
|
}
|
|
|