Merge pull request #381 from AppQuality/develop

release-20250409

Author: marcbon

.github/workflows/add-test-diff.yml

@@ -14,7 +14,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v2
         with:
-          node-version: 14
+          node-version: 18
 
       - name: Install dependencies
         run: |

Dockerfile

@@ -1,4 +1,4 @@
-FROM node:18-alpine3.16 AS node
+FROM node:18.17.1-alpine AS node
 FROM alpine:3.16 as base
 
 COPY --from=node /usr/lib /usr/lib
@@ -20,8 +20,7 @@ COPY . .
 RUN yarn global add npm-run-all
 RUN yarn build
 
-
-FROM node:18-alpine3.16 AS web
+FROM node:18.17.1-alpine AS web
 
 COPY --from=base /dist /app/build
 COPY package*.json /app/

package.json

@@ -21,7 +21,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@appquality/tryber-database": "^0.42.2",
+    "@appquality/tryber-database": "^0.42.27",
     "@appquality/wp-auth": "^1.0.7",
     "@googlemaps/google-maps-services-js": "^3.3.7",
     "@sendgrid/mail": "^7.6.0",
@@ -75,6 +75,7 @@
     "husky": "^7.0.4",
     "jest": "^28.1.0",
     "jest-cli": "^28.1.0",
+    "node-gyp": "^11.1.0",
     "openapi-typescript": "^5.1.1",
     "prettier": "^2.5.1",
     "rimraf": "^3.0.2",

src/features/tranferwise/index.ts

@@ -1,7 +1,6 @@
 import { AxiosError } from "@googlemaps/google-maps-services-js/node_modules/axios";
 import axios from "axios";
 import dotenv from "dotenv";
-
 import signRequest from "./signRequest";
 import stringToUuid from "./stringToUuid";
 

src/features/wp/Pages/ManualPageImporter.ts

@@ -0,0 +1,12 @@
+import { PageImporter } from "./PageImporter";
+
+export class ManualPageImporter extends PageImporter {
+  public async updateMetaWithCampaignId(campaignId: number) {
+    const manualLangs = this.getTranslationLanguages();
+    for (const { lang } of manualLangs) {
+      await this.updateMeta(lang, {
+        man_campaign_id: campaignId.toString(),
+      });
+    }
+  }
+}

src/features/wp/Pages/PageImporter.ts

@@ -0,0 +1,250 @@
+import { tryber } from "@src/features/database";
+import crypto from "crypto";
+import { serialize, unserialize } from "php-serialize";
+
+export class PageImporter {
+  private oldCampaignId: number = 0;
+  protected fromId: number = 0;
+  private withTranslations: boolean = false;
+
+  private newId: number = 0;
+
+  private translations: { [key: string]: number } = {};
+
+  constructor({
+    campaignId,
+    pageId,
+    withTranslations,
+  }: {
+    campaignId: number;
+    pageId: number;
+    withTranslations?: boolean;
+  }) {
+    this.oldCampaignId = campaignId;
+    this.fromId = pageId;
+    this.withTranslations = withTranslations ?? false;
+  }
+
+  async createPage() {
+    const page = await tryber.tables.WpPosts.do()
+      .select()
+      .where("ID", this.fromId)
+      .first();
+
+    if (!page) throw new Error("Page not found");
+
+    const { ID, ...rest } = page;
+
+    const newPage = await tryber.tables.WpPosts.do()
+      .insert({
+        ...rest,
+        post_name: "",
+        post_status: "draft",
+      })
+      .returning("ID");
+
+    const meta = await tryber.tables.WpPostmeta.do()
+      .select()
+      .where("post_id", ID);
+
+    if (meta.length) {
+      await tryber.tables.WpPostmeta.do().insert(
+        meta.map((metaItem) => {
+          const { meta_id, ...rest } = metaItem;
+          return {
+            ...rest,
+            post_id: newPage[0].ID ?? newPage[0],
+          };
+        })
+      );
+    }
+
+    const newId = newPage[0].ID ?? newPage[0];
+    this.newId = newId;
+
+    if (this.withTranslations) {
+      await this.linkTranslations();
+    }
+    return newId;
+  }
+
+  protected getTranslationLanguages() {
+    return Object.keys(this.translations).map((lang) => ({
+      lang,
+    }));
+  }
+
+  protected async updateTitle(lang: string, title: (old: string) => string) {
+    if (!this.translations[lang]) return;
+    const oldTitle = await tryber.tables.WpPosts.do()
+      .select("post_title")
+      .where("ID", this.translations[lang])
+      .first();
+    if (!oldTitle) return;
+    const newTitle = title(oldTitle.post_title);
+    await tryber.tables.WpPosts.do()
+      .update({ post_title: newTitle })
+      .where("ID", this.translations[lang]);
+  }
+
+  protected async updateMeta(lang: string, meta: { [key: string]: string }) {
+    if (!this.translations[lang]) return;
+    for (const key in meta) {
+      await tryber.tables.WpPostmeta.do()
+        .update({ meta_value: meta[key] })
+        .where("post_id", this.translations[lang])
+        .where("meta_key", key);
+    }
+  }
+
+  private async linkTranslations() {
+    const defaultLanguage = await this.getDefaultLanguage();
+    if (!defaultLanguage) return;
+
+    const languages = await this.getPolylangLanguages();
+    const manualTranslations: { [key: string]: number } = {
+      [defaultLanguage]: this.newId,
+    };
+    const parsedTranslations = await this.getPageTranslationIds({
+      pageId: this.fromId,
+      defaultLanguage,
+    });
+    for (const t in parsedTranslations) {
+      const translation = new PageImporter({
+        campaignId: this.oldCampaignId,
+        pageId: parsedTranslations[t],
+      });
+      const newTranslationId = await translation.createPage();
+      if (newTranslationId) manualTranslations[t] = newTranslationId;
+    }
+    await this.createPolylangTranslations({
+      id: this.newId,
+      translations: manualTranslations,
+      languages,
+    });
+    this.translations = manualTranslations;
+  }
+
+  private async getDefaultLanguage() {
+    const polylangOptions = await tryber.tables.WpOptions.do()
+      .select("option_value")
+      .where("option_name", "polylang")
+      .first();
+
+    if (!polylangOptions) return false;
+    let parsedOptions: { [key: string]: any } = {};
+    try {
+      parsedOptions = unserialize(polylangOptions.option_value);
+    } catch (e) {
+      return false;
+    }
+    if (!("default_lang" in parsedOptions)) return false;
+    return parsedOptions.default_lang;
+  }
+
+  private async getPolylangLanguages() {
+    const languages = await tryber.tables.WpTermTaxonomy.do()
+      .select("term_id", "description")
+      .where("taxonomy", "language");
+
+    let parsedLanguages: { [key: string]: number } = {};
+    for (const language of languages) {
+      try {
+        const lang = unserialize(language.description);
+        if ("locale" in lang)
+          parsedLanguages[lang.locale.split("_")[0]] = language.term_id;
+      } catch (e) {
+        continue;
+      }
+    }
+    return parsedLanguages;
+  }
+
+  private async createPolylangTranslations({
+    id,
+    translations,
+    languages,
+  }: {
+    id: number;
+    translations: { [key: string]: number };
+    languages: { [key: string]: any };
+  }) {
+    const term_name = crypto
+      .createHash("md5")
+      .update(id.toString())
+      .digest("hex");
+    const term = await tryber.tables.WpTerms.do()
+      .insert({
+        name: `pll_${term_name}`,
+        slug: `pll_${term_name}`,
+      })
+      .returning("term_id");
+
+    const term_id = term[0].term_id ?? term[0];
+
+    await tryber.tables.WpTermTaxonomy.do().insert({
+      term_id: term_id,
+      term_taxonomy_id: term_id,
+      taxonomy: "post_translations",
+      description: serialize(translations),
+    });
+
+    for (const trans of Object.keys(translations)) {
+      const transId = translations[trans];
+      const langId = trans in languages ? languages[trans] : false;
+      if (langId) {
+        await tryber.tables.WpTermRelationships.do().insert({
+          object_id: transId,
+          term_taxonomy_id: langId,
+        });
+        await tryber.tables.WpTermRelationships.do().insert({
+          object_id: transId,
+          term_taxonomy_id: term_id,
+        });
+      }
+    }
+  }
+
+  private async getPageTranslationIds({
+    pageId,
+    defaultLanguage,
+  }: {
+    pageId: number;
+    defaultLanguage: string;
+  }) {
+    const translations = await tryber.tables.WpTermRelationships.do()
+      .select("object_id", "description")
+      .join(
+        "wp_term_taxonomy",
+        "wp_term_taxonomy.term_taxonomy_id",
+        "wp_term_relationships.term_taxonomy_id"
+      )
+      .where("object_id", pageId)
+      .where("taxonomy", "post_translations")
+      .first();
+
+    if (!translations) return {};
+
+    let parsedTranslations: { [key: string]: any } = {};
+    try {
+      parsedTranslations = unserialize(translations.description);
+    } catch (e) {
+      return;
+    }
+
+    if (defaultLanguage in parsedTranslations)
+      delete parsedTranslations[defaultLanguage];
+    return parsedTranslations;
+  }
+
+  public async updateTitleWithCampaignId(campaignId: number) {
+    const langs = this.getTranslationLanguages();
+    for (const { lang } of langs) {
+      await this.updateTitle(lang, (old) =>
+        old.replace(this.oldCampaignId.toString(), campaignId.toString())
+      );
+    }
+  }
+
+  public async updateMetaWithCampaignId(campaignId: number) {}
+}

src/features/wp/Pages/PreviewPageImporter.ts

@@ -0,0 +1,12 @@
+import { PageImporter } from "./PageImporter";
+
+export class PreviewPageImporter extends PageImporter {
+  public async updateMetaWithCampaignId(campaignId: number) {
+    const manualLangs = this.getTranslationLanguages();
+    for (const { lang } of manualLangs) {
+      await this.updateMeta(lang, {
+        preview_campaign_id: campaignId.toString(),
+      });
+    }
+  }
+}

src/features/wp/Pages/importPages.ts

@@ -0,0 +1,43 @@
+import { tryber } from "@src/features/database";
+import { ManualPageImporter } from "./ManualPageImporter";
+import { PreviewPageImporter } from "./PreviewPageImporter";
+
+const importPages = async (from: number, to: number) => {
+  const campaign = await tryber.tables.WpAppqEvdCampaign.do()
+    .select("page_manual_id", "page_preview_id")
+    .where("id", from);
+
+  if (!campaign.length) return;
+
+  const { page_manual_id, page_preview_id } = campaign[0];
+
+  const manual = new ManualPageImporter({
+    campaignId: from,
+    pageId: page_manual_id,
+    withTranslations: true,
+  });
+  const newManId = await manual.createPage();
+  await tryber.tables.WpAppqEvdCampaign.do()
+    .update({
+      page_manual_id: newManId,
+    })
+    .where("id", to);
+  manual.updateTitleWithCampaignId(to);
+  manual.updateMetaWithCampaignId(to);
+
+  const preview = new PreviewPageImporter({
+    campaignId: from,
+    pageId: page_preview_id,
+    withTranslations: true,
+  });
+  const newPrevId = await preview.createPage();
+  await tryber.tables.WpAppqEvdCampaign.do()
+    .update({
+      page_preview_id: newPrevId,
+    })
+    .where("id", to);
+  preview.updateTitleWithCampaignId(to);
+  preview.updateMetaWithCampaignId(to);
+};
+
+export { importPages };