@rnaga/wp-node/transactions/blog.trx.js

👉 **[View Full Documentation at rnaga.github.io/wp-node →](https://rnaga.github.io/wp-node/)**

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.BlogTrx = void 0;
const common_1 = require("../common");
const components_1 = require("../core/components");
const installer_1 = require("../core/installer");
const logger_1 = require("../core/logger");
const blog_util_1 = require("../core/utils/blog.util");
const query_util_1 = require("../core/utils/query.util");
const user_util_1 = require("../core/utils/user.util");
const validator_1 = require("../core/validator");
const database_1 = __importDefault(require("../database"));
const component_1 = require("../decorators/component");
const val = __importStar(require("../validators"));
const link_trx_1 = require("./link.trx");
const meta_trx_1 = require("./meta.trx");
const post_trx_1 = require("./post.trx");
const trx_1 = require("./trx");
const user_trx_1 = require("./user.trx");
let BlogTrx = class BlogTrx extends trx_1.Trx {
    database;
    logger;
    components;
    blogUtil;
    validator;
    constructor(database, logger, components, blogUtil, validator) {
        super(components);
        this.database = database;
        this.logger = logger;
        this.components = components;
        this.blogUtil = blogUtil;
        this.validator = validator;
    }
    // Change site id
    async changeSite(blogId, newSiteId, options) {
        const queryUtil = this.components.get(query_util_1.QueryUtil);
        const { domain, path } = options ?? {};
        const blog = await queryUtil.blogs((query) => {
            query.where("blog_id", blogId).builder.first();
        }, val.database.wpBlogs);
        if (!blog || newSiteId == blog.site_id) {
            // can't move to the same site
            return;
        }
        const newSite = await queryUtil.sites((query) => {
            query.where("id", newSiteId).builder.first();
        }, val.database.wpSite);
        if (!newSite) {
            throw new Error("Site not found");
        }
        return await this.upsert({
            blog_id: blogId,
            site_id: newSiteId,
            domain: domain ?? blog.domain,
            path: path ?? blog.path,
        });
    }
    // wp_insert_site
    // wp_update_site
    async upsert(input, options) {
        const { dontInitialize = false } = options ?? {};
        let update = false;
        let blogBefore = undefined;
        let userId = 0;
        if (input.blog_id && 0 < input.blog_id) {
            update = true;
            blogBefore = await this.blogUtil.get(input.blog_id);
            if (!blogBefore) {
                throw new Error(`Blog not found - ${input.blog_id}`);
            }
            input = {
                ...blogBefore.props,
                blog_meta: await blogBefore.meta.props(),
                ...input,
            };
        }
        else if (input.user_id) {
            userId = input.user_id;
        }
        const parsedInput = val.trx.blogUpsert.parse(input);
        let dataUpsert = {};
        try {
            dataUpsert = this.validator.execAny(update ? val.trx.blogUpdate : val.trx.blogInsert, parsedInput);
        }
        catch (e) {
            this.logger.info(`parse error: ${e}`, { parsedInput });
            throw e;
        }
        let blogId = parsedInput.blog_id ?? 0;
        const trx = await this.database.transaction;
        try {
            if (update) {
                await trx
                    .table(this.tables.get("blogs"))
                    .where("blog_id", parsedInput.blog_id)
                    .update(dataUpsert);
            }
            else {
                await trx
                    .insert(dataUpsert)
                    .into(this.tables.get("blogs"))
                    .then((v) => {
                    blogId = v[0];
                });
            }
        }
        catch (e) {
            await trx.rollback();
            throw new Error(`Failed to insert blog - ${e}`);
        }
        await trx.commit();
        const blog = await this.blogUtil.get(blogId);
        if (!blog.props?.blog_id) {
            throw new Error(`Blog not found - ${blogId}`);
        }
        if (parsedInput.blog_meta) {
            const metaTrx = this.components.get(meta_trx_1.MetaTrx);
            for (const [key, value] of Object.entries(parsedInput.blog_meta)) {
                if (!value) {
                    continue;
                }
                await metaTrx.upsert("blog", blogId, key, value, {
                    serialize: typeof value == "object" || Array.isArray(value),
                });
            }
        }
        if (!update && !dontInitialize) {
            const installer = this.components.get(installer_1.Installer);
            await installer.initializeBlog(blogId, {
                userId,
                title: input.title,
                options: input.options,
            });
        }
        return blogId;
    }
    // wp_delete_site
    async remove(blogId) {
        const blog = await this.blogUtil.get(blogId);
        if (!blog.props?.blog_id) {
            throw new Error(`Blog does not exist - ${blogId}`);
        }
        const installer = this.components.get(installer_1.Installer);
        await installer.uninitializeBlog(blogId);
        const trx = await this.database.transaction;
        try {
            await trx
                .table(this.tables.get("blogmeta"))
                .where("blog_id", blogId)
                .del();
            await trx.table(this.tables.get("blogs")).where("blog_id", blogId).del();
        }
        catch (e) {
            await trx.rollback();
            throw new Error(`Failed to delete blog - ${e}`);
        }
        await trx.commit();
        return blog;
    }
    async addUser(blogId, userId, roleName, options) {
        const queryUtil = this.components.get(query_util_1.QueryUtil);
        const metaTrx = this.components.get(meta_trx_1.MetaTrx);
        const userTrx = this.components.get(user_trx_1.UserTrx);
        const { superAdmin = false } = options ?? {};
        userTrx.usingBlog(blogId);
        metaTrx.usingBlog(blogId);
        queryUtil.usingBlog(blogId);
        const user = queryUtil.users((query) => {
            query.where("ID", userId).builder.first();
        }, val.database.wpUsers);
        if (!user) {
            throw new Error(`user_does_not_exist - userId: ${userId} blogId: ${blogId}`);
        }
        const blog = await queryUtil.blogs((query) => {
            query.where("blog_id", blogId).builder.first();
        }, val.database.wpBlogs);
        if (!blog) {
            throw new Error(`Blog not found - ${blogId}`);
        }
        const primaryBlog = await queryUtil.meta("user", (query) => {
            query.withIds([userId]).withKeys(["primary_blog"]).builder.first();
        }, val.database.wpUserMeta);
        if (!primaryBlog) {
            await metaTrx.upsert("user", userId, "primary_blog", blogId);
            await metaTrx.upsert("user", userId, "source_domain", blog.domain);
        }
        await userTrx.upsertRole(userId, roleName);
        if (superAdmin) {
            await userTrx.syncSuperAdmin(userId, {
                blogId,
            });
        }
        return true;
    }
    // remove_user_from_blog
    async removeUser(blogId, userId, userIdToReassign = 0) {
        const userUtil = this.components.get(user_util_1.UserUtil);
        const metaTrx = this.components.get(meta_trx_1.MetaTrx);
        const userTrx = this.components.get(user_trx_1.UserTrx);
        const linkTrx = this.components.get(link_trx_1.LinkTrx);
        const postTrx = this.components.get(post_trx_1.PostTrx);
        const queryUtil = this.components.get(query_util_1.QueryUtil);
        linkTrx.usingBlog(blogId);
        userTrx.usingBlog(blogId);
        postTrx.usingBlog(blogId);
        queryUtil.usingBlog(blogId);
        const primaryBlog = await queryUtil.meta("user", (query) => {
            query.withIds([userId]).withKeys(["primary_blog"]).builder.first();
        }, val.database.wpUserMeta);
        if (common_1.formatting.primitive(primaryBlog?.meta_value) == blogId) {
            let newBlogId = 0;
            let newDomain = "";
            const blogs = await userUtil.getBlogs(userId);
            for (const blog of blogs) {
                if (blog.blog_id === blogId) {
                    continue;
                }
                newBlogId = blog.blog_id;
                newDomain = blog.domain;
                break;
            }
            if (newBlogId > 0) {
                await metaTrx.upsert("user", userId, "primary_blog", newBlogId);
                await metaTrx.upsert("user", userId, "source_domain", newDomain);
            }
        }
        await userTrx.removeRole(userId, { removeSuperAdmin: false });
        const blogs = await userUtil.getBlogs(userId);
        if (!blogs || 0 >= blogs.length) {
            await metaTrx.remove("user", { objectId: userId, key: "primary_blog" });
            await metaTrx.remove("user", {
                objectId: userId,
                key: "source_domain",
            });
        }
        if (0 < userIdToReassign) {
            await postTrx.changeAuthor(userId, userIdToReassign);
            await linkTrx.changeUser(userId, userIdToReassign);
        }
        return true;
    }
};
exports.BlogTrx = BlogTrx;
exports.BlogTrx = BlogTrx = __decorate([
    (0, component_1.transactions)(),
    __metadata("design:paramtypes", [database_1.default,
        logger_1.Logger,
        components_1.Components,
        blog_util_1.BlogUtil,
        validator_1.Validator])
], BlogTrx);