foundry-sw5e/module/migration.js

/**
 * Perform a system migration for the entire World, applying migrations for Actors, Items, and Compendium packs
 * @return {Promise}      A Promise which resolves once the migration is completed
 */
export const migrateWorld = async function() {
  ui.notifications.info(`Applying SW5e System Migration for version ${game.system.data.version}. Please be patient and do not close your game or shut down your server.`, {permanent: true});

  // Migrate World Actors
  for await ( let a of game.actors.contents ) {
    try {
      console.log(`Checking Actor entity ${a.name} for migration needs`);
      const updateData = await migrateActorData(a.data);
      if ( !foundry.utils.isObjectEmpty(updateData) ) {
        console.log(`Migrating Actor entity ${a.name}`);
        await a.update(updateData, {enforceTypes: false});
      }
    } catch(err) {
      err.message = `Failed sw5e system migration for Actor ${a.name}: ${err.message}`;
      console.error(err);
    }
  }

  // Migrate World Items
  for ( let i of game.items.contents ) {
    try {
      const updateData = migrateItemData(i.toObject());
      if ( !foundry.utils.isObjectEmpty(updateData) ) {
        console.log(`Migrating Item entity ${i.name}`);
        await i.update(updateData, {enforceTypes: false});
      }
    } catch(err) {
      err.message = `Failed sw5e system migration for Item ${i.name}: ${err.message}`;
      console.error(err);
    }
  }

  // Migrate Actor Override Tokens
  for ( let s of game.scenes.contents ) {
    try {
      const updateData = await migrateSceneData(s.data);
      if ( !foundry.utils.isObjectEmpty(updateData) ) {
        console.log(`Migrating Scene entity ${s.name}`);
        await s.update(updateData, {enforceTypes: false});
        // If we do not do this, then synthetic token actors remain in cache
        // with the un-updated actorData.
        s.tokens.contents.forEach(t => t._actor = null);
      }
    } catch(err) {
      err.message = `Failed sw5e system migration for Scene ${s.name}: ${err.message}`;
      console.error(err);
    }
  }

  // Migrate World Compendium Packs
  for ( let p of game.packs ) {
    if ( p.metadata.package !== "world" ) continue;
    if ( !["Actor", "Item", "Scene"].includes(p.metadata.entity) ) continue;
    await migrateCompendium(p);
  }

  // Set the migration as complete
  game.settings.set("sw5e", "systemMigrationVersion", game.system.data.version);
  ui.notifications.info(`SW5e System Migration to version ${game.system.data.version} completed!`, {permanent: true});
};

/* -------------------------------------------- */

/**
 * Apply migration rules to all Entities within a single Compendium pack
 * @param pack
 * @return {Promise}
 */
export const migrateCompendium = async function(pack) {
  const entity = pack.metadata.entity;
  if ( !["Actor", "Item", "Scene"].includes(entity) ) return;

  // Unlock the pack for editing
  const wasLocked = pack.locked;
  await pack.configure({locked: false});

  // Begin by requesting server-side data model migration and get the migrated content
  await pack.migrate();
  const documents = await pack.getDocuments();

  // Iterate over compendium entries - applying fine-tuned migration functions
  for await ( let doc of documents ) {
    let updateData = {};
    try {
      switch (entity) {
        case "Actor":
          updateData = await migrateActorData(doc.data);
          break;
        case "Item":
          updateData = migrateItemData(doc.toObject());
          break;
        case "Scene":
          updateData = await migrateSceneData(doc.data);
          break;
      }
      if ( foundry.utils.isObjectEmpty(updateData) ) continue;

      // Save the entry, if data was changed
      await doc.update(updateData);
      console.log(`Migrated ${entity} entity ${doc.name} in Compendium ${pack.collection}`);
    }

    // Handle migration failures
    catch(err) {
      err.message = `Failed sw5e system migration for entity ${doc.name} in pack ${pack.collection}: ${err.message}`;
      console.error(err);
    }
  }

  // Apply the original locked status for the pack
  await pack.configure({locked: wasLocked});
  console.log(`Migrated all ${entity} entities from Compendium ${pack.collection}`);
};

/* -------------------------------------------- */
/*  Entity Type Migration Helpers               */
/* -------------------------------------------- */

/**
 * Migrate a single Actor entity to incorporate latest data model changes
 * Return an Object of updateData to be applied
 * @param {object} actor    The actor data object to update
 * @return {Object}         The updateData to apply
 */
export const migrateActorData = async function(actor) {
  const updateData = {};

  // Actor Data Updates
  if(actor.data) {
    _migrateActorMovement(actor, updateData);
    _migrateActorSenses(actor, updateData);
    _migrateActorType(actor, updateData);
  }

  // Migrate Owned Items
  if ( !!actor.items ) {
    const items = await actor.items.reduce(async (memo, i) => {
      const results = await memo;

      // Migrate the Owned Item
      const itemData = i instanceof CONFIG.Item.documentClass ? i.toObject() : i;
      let itemUpdate = await migrateActorItemData(itemData, actor);

      // Prepared, Equipped, and Proficient for NPC actors
      if ( actor.type === "npc" ) {
        if (getProperty(itemData.data, "preparation.prepared") === false) itemUpdate["data.preparation.prepared"] = true;
        if (getProperty(itemData.data, "equipped") === false) itemUpdate["data.equipped"] = true;
        if (getProperty(itemData.data, "proficient") === false) itemUpdate["data.proficient"] = true;
      }

      // Update the Owned Item
      if ( !isObjectEmpty(itemUpdate) ) {
        itemUpdate._id = itemData._id;
        console.log(`Migrating Actor ${actor.name}'s ${i.name}`);
        results.push(expandObject(itemUpdate));
      }

      return results;
    }, []);

    if ( items.length > 0 ) updateData.items = items;
  }

  // Update NPC data with new datamodel information
  if (actor.type === "npc") {
    _updateNPCData(actor);
  }

  // migrate powers last since it relies on item classes being migrated first.
  _migrateActorPowers(actor, updateData);
  
  return updateData;
};

/* -------------------------------------------- */


/**
 * Scrub an Actor's system data, removing all keys which are not explicitly defined in the system template
 * @param {Object} actorData    The data object for an Actor
 * @return {Object}             The scrubbed Actor data
 */
function cleanActorData(actorData) {

  // Scrub system data
  const model = game.system.model.Actor[actorData.type];
  actorData.data = filterObject(actorData.data, model);

  // Scrub system flags
  const allowedFlags = CONFIG.SW5E.allowedActorFlags.reduce((obj, f) => {
    obj[f] = null;
    return obj;
  }, {});
  if ( actorData.flags.sw5e ) {
    actorData.flags.sw5e = filterObject(actorData.flags.sw5e, allowedFlags);
  }

  // Return the scrubbed data
  return actorData;
}


/* -------------------------------------------- */

/**
 * Migrate a single Item entity to incorporate latest data model changes
 *
 * @param {object} item  Item data to migrate
 * @return {object}      The updateData to apply
 */
export const migrateItemData = function(item) {
  const updateData = {};
  _migrateItemClassPowerCasting(item, updateData);
  _migrateItemAttunement(item, updateData);
  _migrateItemPowercasting(item, updateData);
  return updateData;
};

/* -------------------------------------------- */

/**
 * Migrate a single owned actor Item entity to incorporate latest data model changes
 * @param item
 * @param actor
 */
export const migrateActorItemData = async function(item, actor) {
  const updateData = {};
  _migrateItemClassPowerCasting(item, updateData);
  _migrateItemAttunement(item, updateData);
  _migrateItemPowercasting(item, updateData);
  await _migrateItemPower(item, actor, updateData);
  return updateData;
};

/* -------------------------------------------- */

/**
 * Migrate a single Scene entity to incorporate changes to the data model of it's actor data overrides
 * Return an Object of updateData to be applied
 * @param {Object} scene  The Scene data to Update
 * @return {Object}       The updateData to apply
 */
 export const migrateSceneData = async function(scene) {
    const tokens = await Promise.all(scene.tokens.map(async token => {
      const t = token.toJSON();
      if (!t.actorId || t.actorLink) {
        t.actorData = {};
      }
      else if (!game.actors.has(t.actorId)) {
        t.actorId = null;
        t.actorData = {};
      } else if ( !t.actorLink ) {
        const actorData = duplicate(t.actorData);
        actorData.type = token.actor?.type;
        const update = migrateActorData(actorData);
        ['items', 'effects'].forEach(embeddedName => {
          if (!update[embeddedName]?.length) return;
          const updates = new Map(update[embeddedName].map(u => [u._id, u]));
          t.actorData[embeddedName].forEach(original => {
            const update = updates.get(original._id);
            if (update) mergeObject(original, update);
          });
          delete update[embeddedName];
        });

        mergeObject(t.actorData, update);
      }
      return t;
    }));
    return {tokens};
};

/* -------------------------------------------- */
/*  Low level migration utilities
/* -------------------------------------------- */

/* -------------------------------------------- */

/**
 * Update an NPC Actor's data based on compendium
 * @param {Object} actor    The data object for an Actor
 * @return {Object}         The updated Actor
 */
function _updateNPCData(actor) {

  let actorData = actor.data;
  const updateData = {};
  // check for flag.core, if not there is no compendium monster so exit
  const hasSource = actor?.flags?.core?.sourceId !== undefined;
  if (!hasSource) return actor;
  // shortcut out if dataVersion flag is set to 1.2.4 or higher
  const hasDataVersion = actor?.flags?.sw5e?.dataVersion !== undefined;
  if (hasDataVersion && (actor.flags.sw5e.dataVersion === "1.2.4" || isNewerVersion("1.2.4", actor.flags.sw5e.dataVersion))) return actor;
  // Check to see what the source of NPC is
  const sourceId = actor.flags.core.sourceId;
  const coreSource = sourceId.substr(0,sourceId.length-17);
  const core_id = sourceId.substr(sourceId.length-16,16);
  if (coreSource === "Compendium.sw5e.monsters"){
    game.packs.get("sw5e.monsters").getEntity(core_id).then(monster => {
      const monsterData = monster.data.data;
      // copy movement[], senses[], powercasting, force[], tech[], powerForceLevel, powerTechLevel
      updateData["data.attributes.movement"] = monsterData.attributes.movement;
      updateData["data.attributes.senses"] = monsterData.attributes.senses;
      updateData["data.attributes.powercasting"] = monsterData.attributes.powercasting;
      updateData["data.attributes.force"] = monsterData.attributes.force;
      updateData["data.attributes.tech"] = monsterData.attributes.tech;
      updateData["data.details.powerForceLevel"] = monsterData.details.powerForceLevel;
      updateData["data.details.powerTechLevel"] = monsterData.details.powerTechLevel;
      // push missing powers onto actor
      let newPowers = [];
      for ( let i of monster.items ) {
          const itemData = i.data;
          if ( itemData.type === "power" ) {
            const itemCompendium_id = itemData.flags?.core?.sourceId.split(".").slice(-1)[0];
            let hasPower = !!actor.items.find(item => item.flags?.core?.sourceId.split(".").slice(-1)[0] === itemCompendium_id);
            if (!hasPower) {
              // Clone power to new object. Don't know if it is technically needed, but seems to prevent some weirdness.
              const newPower = JSON.parse(JSON.stringify(itemData));

              newPowers.push(newPower);
            }
          }
      }

      // get actor to create new powers
      const liveActor = game.actors.get(actor._id);
      // create the powers on the actor
      liveActor.createEmbeddedEntity("OwnedItem", newPowers);

      // set flag to check to see if migration has been done so we don't do it again.
      liveActor.setFlag("sw5e", "dataVersion", "1.2.4");
    })  
  }


  //merge object
  actorData = mergeObject(actorData, updateData);
  // Return the scrubbed data
  return actor;
}


/**
 * Migrate the actor speed string to movement object
 * @private
 */
function _migrateActorMovement(actorData, updateData) {
  const ad = actorData.data;

  // Work is needed if old data is present
  const old = actorData.type === 'vehicle' ? ad?.attributes?.speed : ad?.attributes?.speed?.value;
  const hasOld = old !== undefined;
  if ( hasOld ) {

    // If new data is not present, migrate the old data
    const hasNew = ad?.attributes?.movement?.walk !== undefined;
    if ( !hasNew && (typeof old === "string") ) {
      const s = (old || "").split(" ");
      if ( s.length > 0 ) updateData["data.attributes.movement.walk"] = Number.isNumeric(s[0]) ? parseInt(s[0]) : null;
    }

    // Remove the old attribute
    updateData["data.attributes.-=speed"] = null;
  }
  return updateData
}

/* -------------------------------------------- */

/**
 * Migrate the actor speed string to movement object
 * @private
 */
function _migrateActorPowers(actorData, updateData) {
  const ad = actorData.data;

  // If new Force & Tech data is not present, create it
  let hasNewAttrib = ad?.attributes?.force?.level !== undefined;
  if ( !hasNewAttrib ) {
    updateData["data.attributes.force.known.value"] = 0;
    updateData["data.attributes.force.known.max"] = 0;
    updateData["data.attributes.force.points.value"] = 0;
    updateData["data.attributes.force.points.min"] = 0;
    updateData["data.attributes.force.points.max"] = 0;
    updateData["data.attributes.force.points.temp"] = null;
    updateData["data.attributes.force.points.tempmax"] = null;
    updateData["data.attributes.force.level"] = 0;
    updateData["data.attributes.tech.known.value"] = 0;
    updateData["data.attributes.tech.known.max"] = 0;
    updateData["data.attributes.tech.points.value"] = 0;
    updateData["data.attributes.tech.points.min"] = 0;
    updateData["data.attributes.tech.points.max"] = 0;
    updateData["data.attributes.tech.points.temp"] = null;
    updateData["data.attributes.tech.points.tempmax"] = null;
    updateData["data.attributes.tech.level"] = 0;
  }

  // If new Power F/T split data is not present, create it
  const hasNewLimit = ad?.powers?.power1?.foverride !== undefined;
  if ( !hasNewLimit ) {
    for (let i = 1; i <= 9; i++) { 
      // add new 
      updateData["data.powers.power" + i + ".fvalue"] = getProperty(ad.powers,"power" + i + ".value");
      updateData["data.powers.power" + i + ".fmax"] = getProperty(ad.powers,"power" + i + ".max");
      updateData["data.powers.power" + i + ".foverride"] = null;
      updateData["data.powers.power" + i + ".tvalue"] = getProperty(ad.powers,"power" + i + ".value");
      updateData["data.powers.power" + i + ".tmax"] = getProperty(ad.powers,"power" + i + ".max");
      updateData["data.powers.power" + i + ".toverride"] = null;
      //remove old
      updateData["data.powers.power" + i + ".-=value"] = null;
      updateData["data.powers.power" + i + ".-=override"] = null;
    }
  }
  // If new Bonus Power DC data is not present, create it
  const hasNewBonus = ad?.bonuses?.power?.forceLightDC !== undefined;
  if ( !hasNewBonus ) {
    updateData["data.bonuses.power.forceLightDC"] = "";
    updateData["data.bonuses.power.forceDarkDC"] = "";
    updateData["data.bonuses.power.forceUnivDC"] = "";
    updateData["data.bonuses.power.techDC"] = "";
  }

  // Remove the Power DC Bonus
  updateData["data.bonuses.power.-=dc"] = null;

  return updateData
}

/* -------------------------------------------- */

/**
 * Migrate the actor traits.senses string to attributes.senses object
 * @private
 */
function _migrateActorSenses(actor, updateData) {
  const ad = actor.data;
  if ( ad?.traits?.senses === undefined ) return;
  const original = ad.traits.senses || "";
  if ( typeof original !== "string" ) return;

  // Try to match old senses with the format like "Darkvision 60 ft, Blindsight 30 ft"
  const pattern = /([A-z]+)\s?([0-9]+)\s?([A-z]+)?/;
  let wasMatched = false;

  // Match each comma-separated term
  for ( let s of original.split(",") ) {
    s = s.trim();
    const match = s.match(pattern);
    if ( !match ) continue;
    const type = match[1].toLowerCase();
    if ( type in CONFIG.SW5E.senses ) {
      updateData[`data.attributes.senses.${type}`] = Number(match[2]).toNearest(0.5);
      wasMatched = true;
    }
  }

  // If nothing was matched, but there was an old string - put the whole thing in "special"
  if ( !wasMatched && !!original ) {
    updateData["data.attributes.senses.special"] = original;
  }

  // Remove the old traits.senses string once the migration is complete
  updateData["data.traits.-=senses"] = null;
  return updateData;
}

/* -------------------------------------------- */

/**
 * Migrate the actor details.type string to object
 * @private
 */
function _migrateActorType(actor, updateData) {
  const ad = actor.data;
  const original = ad.details?.type;
  if ( typeof original !== "string" ) return;

  // New default data structure
  let data = {
    "value": "",
    "subtype": "",
    "swarm": "",
    "custom": ""
  }

  // Specifics
  // (Some of these have weird names, these need to be addressed individually)
  if (original === "force entity") {
    data.value = "force";
    data.subtype = "storm";
  } else if (original === "human") {
    data.value = "humanoid";
    data.subtype = "human";
  } else if (["humanoid (any)", "humanoid (Villainous"].includes(original)) {
    data.value = "humanoid";
  } else if (original === "tree") {
    data.value = "plant";
    data.subtype = "tree";
  } else if (original === "(humanoid) or Large (beast) force entity") {
    data.value = "force";
  } else if (original === "droid (appears human)") {
    data.value = "droid";
  } else {
    // Match the existing string
    const pattern = /^(?:swarm of (?<size>[\w\-]+) )?(?<type>[^(]+?)(?:\((?<subtype>[^)]+)\))?$/i;
    const match = original.trim().match(pattern);
    if (match) {

      // Match a known creature type
      const typeLc = match.groups.type.trim().toLowerCase();
      const typeMatch = Object.entries(CONFIG.SW5E.creatureTypes).find(([k, v]) => {
        return (typeLc === k) ||
            (typeLc === game.i18n.localize(v).toLowerCase()) ||
            (typeLc === game.i18n.localize(`${v}Pl`).toLowerCase());
      });
      if (typeMatch) data.value = typeMatch[0];
      else {
        data.value = "custom";
        data.custom = match.groups.type.trim().titleCase();
      }
      data.subtype = match.groups.subtype?.trim().titleCase() || "";

      // Match a swarm
      const isNamedSwarm = actor.name.startsWith(game.i18n.localize("SW5E.CreatureSwarm"));
      if (match.groups.size || isNamedSwarm) {
        const sizeLc = match.groups.size ? match.groups.size.trim().toLowerCase() : "tiny";
        const sizeMatch = Object.entries(CONFIG.SW5E.actorSizes).find(([k, v]) => {
          return (sizeLc === k) || (sizeLc === game.i18n.localize(v).toLowerCase());
        });
        data.swarm = sizeMatch ? sizeMatch[0] : "tiny";
      } else data.swarm = "";
    }

    // No match found
    else {
      data.value = "custom";
      data.custom = original;
    }
  }

  // Update the actor data
  updateData["data.details.type"] = data;
  return updateData;
}

/* -------------------------------------------- */

/**
 * @private
 */
function _migrateItemClassPowerCasting(item, updateData) {
  if (item.type === "class"){
    switch (item.name){
      case "Consular": 
        updateData["data.powercasting"] = {
          progression: "consular",
          ability: ""
        };
        break;
      case "Engineer":

        updateData["data.powercasting"] = {
          progression: "engineer",
          ability: ""
        };
        break;
      case "Guardian":
        updateData["data.powercasting"] = {
          progression: "guardian",
          ability: ""
        };
        break;
      case "Scout":
        updateData["data.powercasting"] = {
          progression: "scout",
          ability: ""
        };
        break;
      case "Sentinel":
        updateData["data.powercasting"] = {
          progression: "sentinel",
          ability: ""
        };
        break;
    }
  }
  return updateData;
}

/* -------------------------------------------- */

/**
 * Update an Power Item's data based on compendium
 * @param {Object} item    The data object for an item
 * @param {Object} actor    The data object for the actor owning the item
 * @private
 */
async function _migrateItemPower(item, actor, updateData) {
  // if item is not a power shortcut out
  if (item.type !== "power") return updateData;

  console.log(`Checking Actor ${actor.name}'s ${item.name} for migration needs`);
  // check for flag.core, if not there is no compendium power so exit
  const hasSource = item?.flags?.core?.sourceId !== undefined;
  if (!hasSource) return updateData;

  // shortcut out if dataVersion flag is set to 1.2.4 or higher
  const hasDataVersion = item?.flags?.sw5e?.dataVersion !== undefined;
  if (hasDataVersion && (item.flags.sw5e.dataVersion === "1.2.4" || isNewerVersion("1.2.4", item.flags.sw5e.dataVersion))) return updateData;
  
  // Check to see what the source of Power is
  const sourceId = item.flags.core.sourceId;
  const coreSource = sourceId.substr(0, sourceId.length - 17);
  const core_id = sourceId.substr(sourceId.length - 16, 16);
  
  //if power type is not force or tech  exit out
  let powerType = "none";
  if (coreSource === "Compendium.sw5e.forcepowers") powerType = "sw5e.forcepowers";
  if (coreSource === "Compendium.sw5e.techpowers") powerType = "sw5e.techpowers";
  if (powerType === "none") return updateData;

    const corePower = duplicate(await game.packs.get(powerType).getEntity(core_id));
    console.log(`Updating Actor ${actor.name}'s ${item.name} from compendium`);
    const corePowerData = corePower.data;
    // copy Core Power Data over original Power
    updateData["data"] = corePowerData;
    updateData["flags"] = {"sw5e": {"dataVersion": "1.2.4"}};

    return updateData;
    
 
  //game.packs.get(powerType).getEntity(core_id).then(corePower => {

  //})  
}

/* -------------------------------------------- */

/**
 * Delete the old data.attuned boolean
 *
 * @param {object} item        Item data to migrate
 * @param {object} updateData  Existing update to expand upon
 * @return {object}            The updateData to apply
 * @private
 */
function _migrateItemAttunement(item, updateData) {
  if ( item.data?.attuned === undefined ) return updateData;
  updateData["data.attunement"] = CONFIG.SW5E.attunementTypes.NONE;
  updateData["data.-=attuned"] = null;
  return updateData;
}

/* -------------------------------------------- */

/**
 * Replace class powercasting string to object.
 *
 * @param {object} item        Item data to migrate
 * @param {object} updateData  Existing update to expand upon
 * @return {object}            The updateData to apply
 * @private
 */
 function _migrateItemPowercasting(item, updateData) {
  if ( item.type !== "class" || (foundry.utils.getType(item.data.powercasting) === "Object") ) return updateData;
  updateData["data.powercasting"] = {
    progression: item.data.powercasting,
    ability: ""
  };
  return updateData;
}


/* -------------------------------------------- */

/**
 * A general tool to purge flags from all entities in a Compendium pack.
 * @param {Compendium} pack   The compendium pack to clean
 * @private
 */
export async function purgeFlags(pack) {
  const cleanFlags = (flags) => {
    const flags5e = flags.sw5e || null;
    return flags5e ? {sw5e: flags5e} : {};
  };
  await pack.configure({locked: false});
  const content = await pack.getContent();
  for ( let entity of content ) {
    const update = {_id: entity.id, flags: cleanFlags(entity.data.flags)};
    if ( pack.entity === "Actor" ) {
      update.items = entity.data.items.map(i => {
        i.flags = cleanFlags(i.flags);
        return i;
      })
    }
    await pack.updateEntity(update, {recursive: false});
    console.log(`Purged flags from ${entity.name}`);
  }
  await pack.configure({locked: true});
}

/* -------------------------------------------- */


/**
 * Purge the data model of any inner objects which have been flagged as _deprecated.
 * @param {object} data   The data to clean
 * @private
 */
export function removeDeprecatedObjects(data) {
  for ( let [k, v] of Object.entries(data) ) {
    if ( getType(v) === "Object" ) {
      if (v._deprecated === true) {
        console.log(`Deleting deprecated object key ${k}`);
        delete data[k];
      }
      else removeDeprecatedObjects(v);
    }
  }
  return data;
}