ds4/src/module/migrations/004.ts

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

import { DS4SpellDataSourceData } from "../item/item-data-source";
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?.entities ?? []) {
//         try {
//             const updateData = getItemUpdateData(item._data);
//             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: DeepPartial<Item.Data>) {
//     if (!["spell"].includes(itemData.type ?? "")) return undefined;
//     const updateData: Record<string, unknown> = {
//         "-=data.scrollPrice": null,
//         "data.minimumLevels": { healer: null, wizard: null, sorcerer: null },
//     };
//     if (((itemData.data as DS4SpellDataSourceData).cooldownDuration.unit as string) === "custom") {
//         updateData["data.cooldownDuration.unit"] = "rounds";
//     }
//     return updateData;
// }

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

// function getActorUpdateData(actorData: DeepPartial<Actor.Data>) {
//     let hasItemUpdates = false;
//     const items = actorData.items?.map((itemData) => {
//         const update = itemData ? getItemUpdateData(itemData) : undefined;
//         if (update) {
//             hasItemUpdates = true;
//             return mergeObject(itemData, update, { enforceTypes: false, inplace: false });
//         } else {
//             return itemData;
//         }
//     });
//     const updateData: Record<string, unknown> = {};
//     if (actorData.type === "character") {
//         updateData["data.slayerPoints"] = { value: 0 };
//     }
//     if (hasItemUpdates) {
//         updateData["items"] = items;
//     }
//     return updateData;
// }

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

// function getSceneUpdateData(sceneData: Scene.Data) {
//     let hasTokenUpdates = false;
//     const tokens = sceneData.tokens.map((tokenData) => {
//         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 });
//     await compendium.migrate({});

//     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.configure({ locked: wasLocked });
// }