ds4/src/module/migrations/002.ts

// SPDX-FileCopyrightText: 2021 Johannes Loher
//
// SPDX-License-Identifier: MIT

import logger from "../logger";

// export async function migrate(): Promise<void> {
//     await migrateItems();
//     await migrateActors();
//     await migrateScenes();
//     await migrateCompendiums();
// }

// async function migrateItems() {
//     for (const item of getGame().items?.contents ?? []) {
//         try {
//             const updateData = getItemUpdateData(item.toObject());
//             if (updateData) {
//                 logger.info(`Migrating Item entity ${item.name} (${item.id})`);
//                 await item.update(updateData), { enforceTypes: false };
//             }
//         } catch (err) {
//             err.message = `Error during migration of Item entity ${item.name} (${item.id}), continuing anyways.`;
//             logger.error(err);
//         }
//     }
// }

// function getItemUpdateData(itemData: foundry.data.ItemData["_source"]) {
//     if (!["equipment", "trinket"].includes(itemData.type ?? "")) return undefined;
//     return { type: itemData.type === "equipment" ? ("loot" as const) : ("equipment" as const) };
// }

// async function migrateActors() {
//     for (const actor of getGame().actors?.contents ?? []) {
//         try {
//             const updateData = getActorUpdateData(actor.toObject());
//             if (updateData) {
//                 logger.info(`Migrating Actor entity ${actor.name} (${actor.id})`);
//                 await actor.update(updateData);
//             }
//         } catch (err) {
//             err.message = `Error during migration of Actor entity ${actor.name} (${actor.id}), continuing anyways.`;
//             logger.error(err);
//         }
//     }
// }

// function getActorUpdateData(actorData: foundry.data.ActorData["_source"]) {
//     let hasItemUpdates = false;
//     const items = actorData.items.map((itemData: foundry.data.ItemData["_source"]) => {
//         const update = itemData ? getItemUpdateData(itemData) : undefined;
//         if (update) {
//             hasItemUpdates = true;
//             return { ...itemData, ...update };
//         } else {
//             return itemData;
//         }
//     });
//     return hasItemUpdates ? { items } : undefined;
// }

// async function migrateScenes() {
//     for (const scene of getGame().scenes?.contents ?? []) {
//         try {
//             const updateData = getSceneUpdateData(scene.toObject());
//             if (updateData) {
//                 logger.info(`Migrating Scene entity ${scene.name} (${scene.id})`);
//                 await scene.update(updateData);
//             }
//         } catch (err) {
//             err.message = `Error during migration of Scene document ${scene.name} (${scene.id}), continuing anyways.`;
//             logger.error(err);
//         }
//     }
// }

// function getSceneUpdateData(scene: Scene) {
//     let hasTokenUpdates = false;
//     // TODO: Continue from here
//     const tokens = scene.tokens.map((tokenData: foundry.data.TokenData["_source"]) => {
//         if (!tokenData.actorId || tokenData.actorLink) {
//             tokenData.actorData = {};
//         } else if (!getGame().actors?.has(tokenData.actorId)) {
//             tokenData.actorId = null;
//             tokenData.actorData = {};
//         } else if (!tokenData.actorLink) {
//             const actorData = duplicate(tokenData.actorData);
//             actorData.type = token.actor?.type;
//         }

//         if (!tokenData.actorId || tokenData.actorLink || tokenData.actorData.data) {
//             tokenData.actorData = {};
//             hasTokenUpdates = true;
//             return tokenData;
//         }
//         const token = new Token(tokenData);
//         if (!token.actor) {
//             tokenData.actorId = null as unknown as string;
//             tokenData.actorData = {};
//             hasTokenUpdates = true;
//         } else if (!tokenData.actorLink) {
//             const actorUpdateData = getActorUpdateData(token.data.actorData);
//             tokenData.actorData = mergeObject(token.data.actorData, actorUpdateData);
//             hasTokenUpdates = true;
//         }
//         return tokenData;
//     });
//     if (!hasTokenUpdates) return undefined;
//     return hasTokenUpdates ? { tokens } : undefined;
// }

// async function migrateCompendiums() {
//     for (const compendium of getGame().packs ?? []) {
//         if (compendium.metadata.package !== "world") continue;
//         if (!["Actor", "Item", "Scene"].includes(compendium.metadata.entity)) continue;
//         await migrateCompendium(compendium);
//     }
// }

// async function migrateCompendium(compendium: Compendium) {
//     const entityName = compendium.metadata.entity;
//     if (!["Actor", "Item", "Scene"].includes(entityName)) return;
//     const wasLocked = compendium.locked;
//     await compendium.configure({ locked: false });

//     const content = await compendium.getContent();

//     for (const entity of content) {
//         try {
//             const getUpdateData = (entity: Entity) => {
//                 switch (entityName) {
//                     case "Item":
//                         return getItemUpdateData(entity._data);
//                     case "Actor":
//                         return getActorUpdateData(entity._data);
//                     case "Scene":
//                         return getSceneUpdateData(entity._data as Scene.Data);
//                 }
//             };
//             const updateData = getUpdateData(entity);
//             if (updateData) {
//                 logger.info(`Migrating entity ${entity.name} (${entity.id}) in compendium ${compendium.collection}`);
//                 await compendium.updateEntity({ ...updateData, _id: entity._id });
//             }
//         } catch (err) {
//             err.message = `Error during migration of entity ${entity.name} (${entity.id}) in compendium ${compendium.collection}, continuing anyways.`;
//             logger.error(err);
//         }
//     }

//     await compendium.migrate({});
//     await compendium.configure({ locked: wasLocked });
// }