To do for now

Brainstorm

• The methods, property and design of:
  • How environments and systems interconnect
  • EnvironmentService
    • getEnvironment -- if does not exist, warn
    • getEnvironmentWhenLoaded -- returns promise which resolves when environment loaded all services
    • bindEnvironmentType(environmentType, action)
      • bind default ones:
        • global
        • privateServer
        • reservedServer
    • unbindEnvironmentType(environmentType)
    • canBroadcastGlobally - default false, if remains false ignore changes
  • Environment (object)

Mostly System / Environments

• Create ban and unban command
• See RoleService 'Role Order' and consolidate that: #102
• Create objects
  • Have parent object called 'Record'
  • A property settings which is the record
  • Think how expirys will work, be hidden and eventually removed when the original player joins the server
  • Simply have a record:hasExpired(pathwayToTable) method and then check for this within BanService and LongtermService
  • Have record.changed point to record.settings.changed
  • record:update(settingsPathway, value) which handles the abstraction recordChanged does
  • ensure createRecord and removeRecord work properly (e.g. account for environment, return object, destroy object, nil from dictionary)
  • A method within services to associate properties (such as names, userids, environments, etc) to the object
    • Make sure to remain environment specific!!
    • System:getRecordsWithSettings(...)
    • System:getRecordsWithSetting(pathway, environment) - if first time, sets up a records descendant changed signal and association table
    • getRecordWithSetting - same as above but results[1]
    • Make sure it functions like current TaskService setup
    • Convert TaskService to this new method
  • All service method APIs should have an end environment paramter. If nil, this will default to the global environment object
    • Change environment key to environmentUID
    • Setup an environment service and module
      • Environment.getUIDFromType()
      • bind and unbind methods which determines how UIDFromType works
      • CONSIDER HOW NON-GLOBAL ENVIRONMENTTYPE ROLES WORK (e.g. PrivateService, ReservedServer, etc)
        • We still want them to remain on the Global environment, but to create different environments when criteria is met
        • It's also important that when a role has the global UID but a non-global Type then it gets disabled for that server. Consider an 'active' property for roles that when set to false then wipes it from the user role information records
        • ensure change differences within studio/config then apply ingame for all environments
      • completely setup config (see more details below)
      • use getUIDFromType within config and have the environmentUID set before being added into the temp/perm records
    • Introduce a method/signal where you can listen for environments loaded, then in framework, wait for Global environment to load before completing initialisation
    • Introduce a job.environment which is passed down from CommandService verification
• Setup Record System objects:
  • Ban
  • Command
  • Job
  • Longterm
  • Role
  • Setting
  • Warn
• For the following services...
  • Update their events/signals
  • Update all methods to include environments (and to remove isPerm/Global)
  • Sevices:
    • BanService
    • CommandService
    • JobService
    • LongtermService
    • RoleService
    • SettingService
    • WarnService

Additional

• Ensure methods like Args getSystemSetting/getPlayerSetting) are fully updated with environments
• Update state tables such as the following so that they work for multiple environment, instead of single initialisation
  • CommandService 'lowerCaseNameAndAliasToCommandDictionary') -- IGNORE THIS, ITS ACTUALLY FINE
  • SettingService (e.g. 'lowerCaseColorNames')
  • Revamp all record:getTable and setTable
  • TaskService everything
• THINK ABOUT THIS: Everything related to Framework.loaded needs to be revamped
  • This method needs to entirely disappear
  • Maybe an environmentLoaded alternative which can be listened for?
  • What happens about framework:waitUntilLoaded? Should this wait be removed entirely, but then how do you ensure an environment is loaded when you wish to retrieve information about it? Maybe a wait until specific environment loaded event/method instead?
  • For example, what happens about BanService.playerLoadedMethod if this is called before the environment loaded?
• Config
  • Update all config (bans, roles, etc) with EnvironmentType
  • When config is loaded in game, sort based upon its EnvironmentType
• Setup an 'Individual' EnvironmentType Enum (and replace with Other)

Test

• Expiry on different layers of records work (and state:add())
• Changing a records environmentType and environmentUID
• The creating and saving of records, such as bans, in non global environments like private servers
• The changing of default information within config/studio after already creating and changing things within a non global env

Networking

• User information which determines if they have the main menu open/closed
• User information to determine which pages/info they can access
• A remote event fired to server to initially retrieve information and inform server menu is open/closed
• The remote event listened on client to handle system/record data changes
• Make sure to filter out tables which have an expired expiryTime
• Have system/record deduce who needs updating and can access information, and fire off accordingly

Data Caps

• Explore DataStore limits. Do new datastores need to be created per system instead of keys?
• Consider creating an arg called 'recordString'. It behaves the same as a normal string but gets capped to around 200 characters
• A Cap on the total number of record types (bans, roles, etc)

from core.