@rnaga/wp-node 1.1.0

package/query-builder/users.query.js

@@ -0,0 +1,188 @@
+"use strict";
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var UsersQuery_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsersQuery = void 0;
+const components_1 = require("../core/components");
+const roles_1 = require("../core/roles");
+const tables_1 = require("../core/tables");
+const component_1 = require("../decorators/component");
+const alias_1 = require("./alias");
+const meta_query_1 = require("./meta.query");
+const posts_query_1 = require("./posts.query");
+const query_builder_1 = require("./query-builder");
+const query_builders_1 = require("./query-builders");
+let UsersQuery = UsersQuery_1 = class UsersQuery extends query_builder_1.QueryBuilder {
+    components;
+    roles;
+    alias;
+    builders;
+    builder;
+    table = "users";
+    #metaJoined = false;
+    constructor(components, roles, alias, builders, builder) {
+        super(alias, builders, builder, UsersQuery_1);
+        this.components = components;
+        this.roles = roles;
+        this.alias = alias;
+        this.builders = builders;
+        this.builder = builder;
+    }
+    get from() {
+        this.builder.table(this.alias.as(this.table));
+        return this;
+    }
+    get(u) {
+        if (typeof u === "string") {
+            this.where("user_nicename", u)
+                .or.where("user_email", u)
+                .or.where("display_name", u)
+                .or.where("user_login", u);
+        }
+        else {
+            this.whereIn("ID", [u]);
+        }
+        this.builder.first();
+        return this;
+    }
+    select(columns) {
+        this.builder.select(columns);
+        return this;
+    }
+    withMeta(type = "right") {
+        if (this.#metaJoined) {
+            return this;
+        }
+        const meta = this.builders.get(meta_query_1.MetaQuery, this.builder, this.alias);
+        meta.setPrimaryTable("user").from.joinPrimary(type);
+        this.#metaJoined = true;
+        return this;
+    }
+    withPublishedPosts() {
+        const { column } = this.alias;
+        this.builder.whereIn(column("users", "ID"), (subBuilder) => {
+            this.builders
+                .get(posts_query_1.PostsQuery, subBuilder)
+                .from.select(["post_author"])
+                .where("post_status", "publish")
+                .where("post_type", "post");
+        });
+        return this;
+    }
+    withBlogIds(blogIds) {
+        const tables = this.components.get(tables_1.Tables);
+        const { column } = this.alias;
+        const meta = this.builders.get(meta_query_1.MetaQuery);
+        meta.setPrimaryTable("user").from.joinPrimary("inner");
+        for (const blogId of blogIds) {
+            tables.index = blogId;
+            meta.builder.or.where("meta_key", `${tables.prefix}capabilities`);
+        }
+        meta.builder.not.whereILike("meta_value", "a:0:{}");
+        meta.select(["user_id"]);
+        this.builder.whereIn(column("users", "ID"), meta.builder);
+        return this;
+    }
+    // private get metaKeyCapabilities() {
+    //   //return `${this.builders.tables.basePrefix}%capabilities`;
+    //   return `${this.builders.tables.prefix}capabilities`;
+    // }
+    hasRole() {
+        const { column } = this.alias;
+        const meta = this.builders.get(meta_query_1.MetaQuery);
+        meta.setPrimaryTable("user").from.joinPrimary("inner");
+        meta.builder
+            .whereILike("meta_key", `${this.builders.tables.basePrefix}%capabilities`, '"')
+            .not.whereILike("meta_value", "a:0:{}");
+        meta.select(["user_id"]);
+        //if (not) this.builder.whereNotIn(column("users", "ID"), meta.builder);
+        this.builder.whereIn(column("users", "ID"), meta.builder);
+        return this;
+    }
+    hasNoRole() {
+        // this.hasRole(true);
+        // return this;
+        const { column } = this.alias;
+        const meta = this.builders.get(meta_query_1.MetaQuery);
+        meta.setPrimaryTable("user").from.joinPrimary("right");
+        meta.builder.whereILike("meta_key", `${this.builders.tables.basePrefix}%capabilities`, '"');
+        meta.andWhere((query) => {
+            query.setPrimaryTable("user");
+            query.builder.not
+                .where("meta_value", "a:0:{}")
+                .and.not.where("meta_value", "");
+        });
+        meta.select(["user_id"]);
+        this.builder.whereNotIn(column("users", "ID"), meta.builder);
+        return this;
+    }
+    withRoles(roleNames, options) {
+        const { column } = this.alias;
+        const blogIds = options?.blogIds ?? [this.builders.tables.index];
+        const roles = roleNames.map((roleName) => this.roles.get(roleName));
+        if (0 >= roles.length)
+            return this;
+        const tables = this.components.get(tables_1.Tables);
+        const meta = this.builders.get(meta_query_1.MetaQuery);
+        meta.setPrimaryTable("user").from.joinPrimary("inner");
+        if (blogIds.length > 0) {
+            meta.builder.andWhere((query) => {
+                for (const blogId of blogIds) {
+                    tables.index = blogId;
+                    query.orWhere("meta_key", `${tables.prefix}capabilities`);
+                }
+            });
+        }
+        meta.builder.andWhere((query) => {
+            for (const role of roles) {
+                if (!role?.name)
+                    continue;
+                query.orWhereILike("meta_value", `%${role.name.toLowerCase()}%`);
+            }
+        });
+        meta.select(["user_id"]);
+        this.builder.whereIn(column("users", "ID"), meta.builder);
+        return this;
+    }
+    whereIn(column, values) {
+        this.where(column, values);
+        return this;
+    }
+    where(column, value, op = "=") {
+        const { column: toColumn } = this.alias;
+        if (Array.isArray(value)) {
+            op = "in";
+        }
+        this.builder.where(toColumn((column == "meta_key" || column == "meta_value"
+            ? "usermeta"
+            : "users"), column), op, value);
+        return this;
+    }
+    whereLike(column, value, options) {
+        const { column: toColumn } = this.alias;
+        if (options?.not === true) {
+            this.builder.not;
+        }
+        this.builder.whereILike(toColumn("users", column), `%${value}%`);
+        return this;
+    }
+    whereNotLike(column, value) {
+        return this.whereLike(column, value, { not: true });
+    }
+};
+exports.UsersQuery = UsersQuery;
+exports.UsersQuery = UsersQuery = UsersQuery_1 = __decorate([
+    (0, component_1.queryBuilder)(),
+    __metadata("design:paramtypes", [components_1.Components,
+        roles_1.Roles,
+        alias_1.Alias,
+        query_builders_1.QueryBuilders, Object])
+], UsersQuery);

package/schema-builder/proxy.d.ts

@@ -0,0 +1,10 @@
+type FluentProxy = {
+    [key: string]: (...args: any[]) => FluentProxy;
+};
+type Calls = Array<{
+    method: any;
+    args: any[];
+}>;
+export declare const createFluentProxy: () => [FluentProxy, Calls];
+export {};
+//# sourceMappingURL=proxy.d.ts.map

package/schema-builder/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/schema-builder/proxy.ts"],"names":[],"mappings":"AAAA,KAAK,WAAW,GAAG;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,WAAW,CAAC;CAChD,CAAC;AAEF,KAAK,KAAK,GAAG,KAAK,CAAC;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,GAAG,EAAE,CAAA;CAAE,CAAC,CAAC;AAEjD,eAAO,MAAM,iBAAiB,QAAO,CAAC,WAAW,EAAE,KAAK,CAgBvD,CAAC"}

package/schema-builder/proxy.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFluentProxy = void 0;
+const createFluentProxy = () => {
+    const calls = [];
+    const handler = {
+        get: (target, prop, receiver) => {
+            if (typeof prop === "string") {
+                return (...args) => {
+                    calls.push({ method: prop, args });
+                    return receiver;
+                };
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    };
+    return [new Proxy({}, handler), calls];
+};
+exports.createFluentProxy = createFluentProxy;

package/schema-builder/schema-builder.d.ts

@@ -0,0 +1,21 @@
+import { Knex } from "knex";
+import { Config } from "../config";
+import { Tables } from "../core/tables";
+import Database from "../database";
+import type * as types from "../types";
+export declare class SchemaBuilder {
+    private database;
+    private config;
+    tables: Tables;
+    static schema: Record<types.TableNames, types.Schema<types.TableNames>>;
+    constructor(database: Database, config: Config, tables: Tables);
+    private getDefinition;
+    static add(schema: Record<types.TableNames, types.Schema<types.TableNames>>): void;
+    private tableExists;
+    private getColumnNamesFromExistingTable;
+    private getColumnNamesFromSchemaDefinition;
+    private buildColumns;
+    get<T extends types.TableNames>(tableName: T): Promise<(Knex.SchemaBuilder | Knex.Raw<any>)[]>;
+    drop(tableName: types.TableNames): Knex.SchemaBuilder;
+}
+//# sourceMappingURL=schema-builder.d.ts.map

package/schema-builder/schema-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-builder.d.ts","sourceRoot":"","sources":["../../src/schema-builder/schema-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,QAAQ,MAAM,aAAa,CAAC;AAKnC,OAAO,KAAK,KAAK,KAAK,MAAM,UAAU,CAAC;AAEvC,qBACa,aAAa;IAGtB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,MAAM;IACP,MAAM,EAAE,MAAM;IAJvB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;gBAE9D,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACf,MAAM,EAAE,MAAM;IAGvB,OAAO,CAAC,aAAa;IAIrB,MAAM,CAAC,GAAG,CACR,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,GAC/D,IAAI;YAKO,WAAW;YAIX,+BAA+B;IAQ7C,OAAO,CAAC,kCAAkC;IAe1C,OAAO,CAAC,YAAY;IA0Cd,GAAG,CAAC,CAAC,SAAS,KAAK,CAAC,UAAU,EAAE,SAAS,EAAE,CAAC;IA8ElD,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa;CAItD"}

package/schema-builder/schema-builder.js

@@ -0,0 +1,207 @@
+"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 };
+};
+var SchemaBuilder_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaBuilder = void 0;
+const config_1 = require("../config");
+const constants_1 = require("../constants");
+const tables_1 = require("../core/tables");
+const database_1 = __importDefault(require("../database"));
+const component_1 = require("../decorators/component");
+const proxy_1 = require("./proxy");
+const schema = __importStar(require("./schema"));
+let SchemaBuilder = class SchemaBuilder {
+    static { SchemaBuilder_1 = this; }
+    database;
+    config;
+    tables;
+    static schema;
+    constructor(database, config, tables) {
+        this.database = database;
+        this.config = config;
+        this.tables = tables;
+    }
+    getDefinition(name) {
+        return SchemaBuilder_1.schema[name];
+    }
+    static add(schema) {
+        SchemaBuilder_1.schema = { ...SchemaBuilder_1.schema, ...schema };
+    }
+    async tableExists(tableName) {
+        return await this.database.schema.hasTable(this.tables.get(tableName));
+    }
+    async getColumnNamesFromExistingTable(tableName) {
+        const columnInfo = await this.database
+            .connection(this.tables.get(tableName))
+            .columnInfo();
+        return Object.keys(columnInfo);
+    }
+    getColumnNamesFromSchemaDefinition(tableName) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const [proxy, calls] = (0, proxy_1.createFluentProxy)();
+        // Get keys and save chaining methods defined for columns
+        const columns = this.getDefinition(tableName).columns(proxy, this.config);
+        const keys = [];
+        Object.entries(columns).forEach(([key, value]) => value && keys.push(key));
+        return keys;
+    }
+    buildColumns(tableName, tableBuilder, targetColumns) {
+        const [proxy, calls] = (0, proxy_1.createFluentProxy)();
+        // Get keys and save chaining methods defined for columns
+        this.getDefinition(tableName).columns(proxy, this.config);
+        let include = true;
+        let currentColumBuilder = {
+            name: "",
+            instance: undefined,
+        };
+        let currentColumnName = "";
+        for (const { method, args } of calls) {
+            // Method is to initialize Knex.ColumnBuilder
+            if (typeof tableBuilder[method] !== "undefined") {
+                currentColumnName = args[0];
+                // Check if the column should be added
+                include = targetColumns.includes(currentColumnName);
+            }
+            if (include) {
+                // Initialize new ColumnBuilder
+                if (currentColumnName !== currentColumBuilder.name) {
+                    currentColumBuilder = {
+                        name: currentColumnName,
+                        // Initialize new Knex.ColumnBuilder
+                        instance: tableBuilder[method](...args),
+                    };
+                }
+                else {
+                    // Call method for ColumnBuilder
+                    currentColumBuilder.instance[method](...args);
+                }
+            }
+        }
+    }
+    async get(tableName) {
+        const columnNamesFromSchemaDefinition = this.getColumnNamesFromSchemaDefinition(tableName);
+        let targetColumns = columnNamesFromSchemaDefinition;
+        const builders = [];
+        let builder;
+        // Columns
+        if (await this.tableExists(tableName)) {
+            const columnNamesfromExistingTable = await this.getColumnNamesFromExistingTable(tableName);
+            targetColumns = columnNamesFromSchemaDefinition.filter((key) => !columnNamesfromExistingTable.includes(key));
+            if (0 >= targetColumns.length) {
+                return [];
+            }
+            // Alter Table
+            builder = this.database.schema.alterTable(this.tables.get(tableName), (table) => {
+                this.buildColumns(tableName, table, targetColumns);
+            });
+        }
+        else {
+            // Create Table
+            builder = this.database.schema.createTable(this.tables.get(tableName), (table) => {
+                this.buildColumns(tableName, table, targetColumns);
+                table.collate(this.config.config.tableCollate);
+                table.charset(this.config.config.tableCharset);
+            });
+        }
+        builders.push(builder);
+        const definition = this.getDefinition(tableName);
+        // Indexes
+        if (definition.indexes) {
+            const indexes = definition.indexes;
+            builder = this.database.schema.alterTable(this.tables.get(tableName), (table) => {
+                indexes(table, targetColumns);
+            });
+            builders.push(builder);
+        }
+        // Raw queries
+        if (definition.raw) {
+            const raw = definition.raw;
+            const sqls = [];
+            const rawQuery = (sql, binding) => {
+                sqls.push([sql, binding]);
+            };
+            raw(rawQuery, this.tables, targetColumns);
+            if (0 < sqls.length) {
+                for (const sql of sqls) {
+                    builder = this.database.connection.raw(sql[0], sql[1]);
+                }
+                builders.push(builder);
+            }
+        }
+        return builders;
+    }
+    drop(tableName) {
+        return this.database.schema.dropTable(this.tables.get(tableName));
+    }
+};
+exports.SchemaBuilder = SchemaBuilder;
+exports.SchemaBuilder = SchemaBuilder = SchemaBuilder_1 = __decorate([
+    (0, component_1.component)({ scope: constants_1.Scope.Transient }),
+    __metadata("design:paramtypes", [database_1.default,
+        config_1.Config,
+        tables_1.Tables])
+], SchemaBuilder);
+SchemaBuilder.add({
+    blogmeta: schema.blogMeta,
+    blogs: schema.blogs,
+    commentmeta: schema.commentMeta,
+    comments: schema.comments,
+    links: schema.links,
+    options: schema.options,
+    postmeta: schema.postMeta,
+    posts: schema.posts,
+    registration_log: schema.registrationLog,
+    signups: schema.signups,
+    site: schema.site,
+    sitemeta: schema.siteMeta,
+    term_relationships: schema.termRelationships,
+    term_taxonomy: schema.termTaxonomy,
+    termmeta: schema.termMeta,
+    terms: schema.terms,
+    usermeta: schema.userMeta,
+    users: schema.users,
+});

package/schema-builder/schema.d.ts

@@ -0,0 +1,20 @@
+import type * as types from "../types";
+export declare const blogMeta: types.Schema<"blogmeta">;
+export declare const blogs: types.Schema<"blogs">;
+export declare const commentMeta: types.Schema<"commentmeta">;
+export declare const comments: types.Schema<"comments">;
+export declare const links: types.Schema<"links">;
+export declare const options: types.Schema<"options">;
+export declare const postMeta: types.Schema<"postmeta">;
+export declare const posts: types.Schema<"posts">;
+export declare const registrationLog: types.Schema<"registration_log">;
+export declare const signups: types.Schema<"signups">;
+export declare const site: types.Schema<"site">;
+export declare const siteMeta: types.Schema<"sitemeta">;
+export declare const termMeta: types.Schema<"termmeta">;
+export declare const terms: types.Schema<"terms">;
+export declare const termRelationships: types.Schema<"term_relationships">;
+export declare const termTaxonomy: types.Schema<"term_taxonomy">;
+export declare const userMeta: types.Schema<"usermeta">;
+export declare const users: types.Schema<"users">;
+//# sourceMappingURL=schema.d.ts.map

package/schema-builder/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema-builder/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,UAAU,CAAC;AAIvC,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,UAAU,CAkB7C,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,OAAO,CAiCvC,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,aAAa,CAsBnD,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,UAAU,CA4E7C,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,OAAO,CA+BvC,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,SAAS,CAmB3C,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,UAAU,CAkB7C,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,OAAO,CAgFvC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,MAAM,CAAC,kBAAkB,CAe5D,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,SAAS,CAuC3C,CAAC;AAEF,eAAO,MAAM,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,CAgBrC,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,UAAU,CAkB7C,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,UAAU,CAkB7C,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,OAAO,CAkBvC,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,oBAAoB,CAqBhE,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,eAAe,CAuBtD,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,UAAU,CAsB7C,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,OAAO,CAoCvC,CAAC"}