@polyvharmony/live-scenes-sdk 1.2.0-rc.1

package/src/main/ets/modules/product/model/PLVProductContentBean.js

@@ -0,0 +1,73 @@
+var __decorate = (this && this.__decorate) || function (z176, 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(z176, target, key, desc);
+    else
+        for (var a177 = z176.length - 1; a177 >= 0; a177--)
+            if (d = z176[a177])
+                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;
+};
+import { PLVJSONUtils, PLVTextUtils } from '@polyvharmony/live-scenes-foundation';
+let PLVProductContentBean = class PLVProductContentBean {
+    getCover() {
+        return PLVTextUtils.fixPic(this.cover);
+    }
+    isNormalLink() {
+        return 10 == this.linkType;
+    }
+    getLinkByType() {
+        return this.isNormalLink() ? this.link : this.mobileAppLink;
+    }
+    isRealPriceEqualsPrice() {
+        if (this.realPrice && this.price) {
+            const x176 = parseFloat(this.realPrice);
+            const y176 = parseFloat(this.price);
+            return x176.toFixed(2) === y176.toFixed(2);
+        }
+        return false;
+    }
+    isFreeForPay() {
+        return PLVTextUtils.isNumberZero(this.realPrice);
+    }
+    isSrcPriceZero() {
+        return PLVTextUtils.isNumberZero(this.price);
+    }
+    isNormalProduct() {
+        return 'normal' === this.productType;
+    }
+    isFinanceProduct() {
+        return 'finance' === this.productType;
+    }
+    isPositionProduct() {
+        return 'position' === this.productType;
+    }
+    isBigProduct() {
+        return "bigCard" === this.productPushRule;
+    }
+    getParsedFeatures(maxLength = 2) {
+        if (!this.parsedFeatures && this.features) {
+            this.parsedFeatures = PLVJSONUtils.safeParse(this.features);
+            if (this.parsedFeatures) {
+                this.parsedFeatures = this.parsedFeatures.filter((value) => value !== '');
+            }
+            if (this.parsedFeatures && this.parsedFeatures.length > maxLength) {
+                this.parsedFeatures.length = maxLength;
+            }
+        }
+        return this.parsedFeatures;
+    }
+    getTreatment() {
+        if (this.params) {
+            const jsonObject = PLVJSONUtils.safeParse(this.params);
+            if (jsonObject) {
+                return jsonObject['treatment'];
+            }
+        }
+        return '';
+    }
+};
+PLVProductContentBean = __decorate([
+    Observed
+], PLVProductContentBean);
+export { PLVProductContentBean };

package/src/main/ets/modules/product/model/PLVProductControlEvent.d.ets

@@ -0,0 +1,12 @@
+import { PLVProductContentBean } from './PLVProductContentBean';
+@Observed
+export declare class PLVProductControlEvent {
+    static readonly EVENT = "PRODUCT_MESSAGE";
+    content?: PLVProductContentBean;
+    status?: string;
+    fill(): void;
+    isPutOnShelves(): boolean;
+    isNewly(): boolean;
+    isRedact(): boolean;
+    isPush(): boolean;
+}

package/src/main/ets/modules/product/model/PLVProductControlEvent.js

@@ -0,0 +1,35 @@
+var __decorate = (this && this.__decorate) || function (c177, 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(c177, target, key, desc);
+    else
+        for (var d177 = c177.length - 1; d177 >= 0; d177--)
+            if (d = c177[d177])
+                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;
+};
+import { PLVJSONUtils } from '@polyvharmony/live-scenes-foundation';
+import { PLVSocketMessageEvent } from '../../socket/model/PLVSocketEventConstants';
+import { PLVProductContentBean } from './PLVProductContentBean';
+let PLVProductControlEvent = class PLVProductControlEvent {
+    fill() {
+        this.content = PLVJSONUtils.bean2Bean(new PLVProductContentBean(), this.content);
+    }
+    isPutOnShelves() {
+        return '1' === this.status;
+    }
+    isNewly() {
+        return '4' === this.status;
+    }
+    isRedact() {
+        return '5' === this.status;
+    }
+    isPush() {
+        return '9' === this.status;
+    }
+};
+PLVProductControlEvent.EVENT = PLVSocketMessageEvent.PRODUCT_MESSAGE;
+PLVProductControlEvent = __decorate([
+    Observed
+], PLVProductControlEvent);
+export { PLVProductControlEvent };

package/src/main/ets/modules/product/model/PLVProductDataBean.d.ets

@@ -0,0 +1,11 @@
+import { PLVProductContentBean } from './PLVProductContentBean';
+@Observed
+export declare class PLVProductDataBean {
+    isOpenProduct?: boolean;
+    pushContentBean?: PLVProductContentBean;
+    hotEffectEnable?: boolean;
+    hotEffectTips?: string;
+    hotEffectClickTimes?: number;
+    copy(): PLVProductDataBean;
+    getHotEffectClickTimes(f177?: boolean): string | undefined;
+}

package/src/main/ets/modules/product/model/PLVProductDataBean.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (h177, 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(h177, target, key, desc);
+    else
+        for (var i177 = h177.length - 1; i177 >= 0; i177--)
+            if (d = h177[i177])
+                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 PLVProductDataBean_1;
+import { PLVTextUtils } from '@polyvharmony/live-scenes-foundation';
+let PLVProductDataBean = PLVProductDataBean_1 = class PLVProductDataBean {
+    copy() {
+        const g177 = new PLVProductDataBean_1();
+        g177.isOpenProduct = this.isOpenProduct;
+        g177.pushContentBean = this.pushContentBean;
+        g177.hotEffectEnable = this.hotEffectEnable;
+        g177.hotEffectTips = this.hotEffectTips;
+        g177.hotEffectClickTimes = this.hotEffectClickTimes;
+        return g177;
+    }
+    getHotEffectClickTimes(f177 = true) {
+        if (!this.hotEffectClickTimes && f177) {
+            return undefined;
+        }
+        if ((this.hotEffectClickTimes || 0) > 9999) {
+            return '9999+';
+        }
+        return PLVTextUtils.toString(this.hotEffectClickTimes);
+    }
+};
+PLVProductDataBean = PLVProductDataBean_1 = __decorate([
+    Observed
+], PLVProductDataBean);
+export { PLVProductDataBean };

package/src/main/ets/modules/product/model/PLVProductEvent.d.ets

@@ -0,0 +1,17 @@
+export declare class PLVProductEvent {
+    static readonly EVENT = "PRODUCT_MESSAGE";
+    status?: string;
+    isProductControlEvent(): boolean;
+    isProductRemoveEvent(): boolean;
+    isProductMoveEvent(): boolean;
+    isProductMenuSwitchEvent(): boolean;
+    isPullOffShelves(): boolean;
+    isExpurgate(): boolean;
+    isMoveUp(): boolean;
+    isMoveDown(): boolean;
+    isPutOnShelves(): boolean;
+    isNewly(): boolean;
+    isRedact(): boolean;
+    isPush(): boolean;
+    isMenuSwitch(): boolean;
+}

package/src/main/ets/modules/product/model/PLVProductEvent.js

@@ -0,0 +1,43 @@
+import { PLVSocketMessageEvent } from '../../socket/model/PLVSocketEventConstants';
+export class PLVProductEvent {
+    isProductControlEvent() {
+        return this.isPutOnShelves() || this.isNewly() || this.isRedact() || this.isPush();
+    }
+    isProductRemoveEvent() {
+        return this.isPullOffShelves() || this.isExpurgate();
+    }
+    isProductMoveEvent() {
+        return this.isMoveDown() || this.isMoveUp();
+    }
+    isProductMenuSwitchEvent() {
+        return this.isMenuSwitch();
+    }
+    isPullOffShelves() {
+        return '2' === this.status;
+    }
+    isExpurgate() {
+        return '3' === this.status;
+    }
+    isMoveUp() {
+        return '6' === this.status;
+    }
+    isMoveDown() {
+        return '7' === this.status;
+    }
+    isPutOnShelves() {
+        return '1' === this.status;
+    }
+    isNewly() {
+        return '4' === this.status;
+    }
+    isRedact() {
+        return '5' === this.status;
+    }
+    isPush() {
+        return '9' === this.status;
+    }
+    isMenuSwitch() {
+        return '10' === this.status;
+    }
+}
+PLVProductEvent.EVENT = PLVSocketMessageEvent.PRODUCT_MESSAGE;

package/src/main/ets/modules/product/model/PLVProductMenuSwitchEvent.d.ets

@@ -0,0 +1,13 @@
+export declare class PLVProductMenuSwitchEvent {
+    static readonly EVENT = "PRODUCT_MESSAGE";
+    content?: ContentBean;
+    status?: string;
+}
+export interface ContentBean {
+    content?: object;
+    enabled?: string;
+    menuId?: string;
+    menuType?: string;
+    name?: string;
+    ordered?: number;
+}

package/src/main/ets/modules/product/model/PLVProductMenuSwitchEvent.js

@@ -0,0 +1,4 @@
+import { PLVSocketMessageEvent } from '../../socket/model/PLVSocketEventConstants';
+export class PLVProductMenuSwitchEvent {
+}
+PLVProductMenuSwitchEvent.EVENT = PLVSocketMessageEvent.PRODUCT_MESSAGE;

package/src/main/ets/modules/product/model/PLVProductMoveEvent.d.ets

@@ -0,0 +1,8 @@
+import { PLVProductContentBean } from './PLVProductContentBean';
+export declare class PLVProductMoveEvent {
+    static readonly EVENT = "PRODUCT_MESSAGE";
+    status?: string;
+    content?: PLVProductContentBean[];
+    isMoveUp(): boolean;
+    isMoveDown(): boolean;
+}

package/src/main/ets/modules/product/model/PLVProductMoveEvent.js

@@ -0,0 +1,10 @@
+import { PLVSocketMessageEvent } from '../../socket/model/PLVSocketEventConstants';
+export class PLVProductMoveEvent {
+    isMoveUp() {
+        return '6' === this.status;
+    }
+    isMoveDown() {
+        return '7' === this.status;
+    }
+}
+PLVProductMoveEvent.EVENT = PLVSocketMessageEvent.PRODUCT_MESSAGE;

package/src/main/ets/modules/product/model/PLVProductRemoveEvent.d.ets

@@ -0,0 +1,10 @@
+export declare class PLVProductRemoveEvent {
+    static readonly EVENT = "PRODUCT_MESSAGE";
+    content?: ContentBean;
+    status?: string;
+}
+export interface ContentBean {
+    productId?: number;
+    rank?: number;
+    status?: number;
+}

package/src/main/ets/modules/product/model/PLVProductRemoveEvent.js

@@ -0,0 +1,4 @@
+import { PLVSocketMessageEvent } from '../../socket/model/PLVSocketEventConstants';
+export class PLVProductRemoveEvent {
+}
+PLVProductRemoveEvent.EVENT = PLVSocketMessageEvent.PRODUCT_MESSAGE;

package/src/main/ets/modules/redpack/PLVRedpackManager.d.ets

@@ -0,0 +1,72 @@
+import { PLVBaseModule } from '../../common/PLVBaseModule';
+import { PLVChannelData } from '../../common/PLVChannelData';
+import { IPLVEventNotify } from '@polyvharmony/live-scenes-foundation';
+import { PLVRedPaperForDelayEvent } from '../../modules/interact/redpack/model/PLVRedPaperForDelayEvent';
+import { PLVRedPaperResultEvent } from '../../modules/interact/redpack/model/PLVRedPaperResultEvent';
+import { PLVRedPaperEvent } from '../interact/redpack/model/PLVRedPaperEvent';
+import { RedPaperReceiveType } from '../socket/model/redpack/RedPaperReceiveType';
+/**
+ * 事件类型，可以使用{@link PLVRedpackManager#eventDataNotify}监听对应的事件
+ */
+export type EventDataType = 'redpack_data';
+/**
+ * 红包管理器
+ */
+export declare class PLVRedpackManager extends PLVBaseModule {
+    private redpackMap;
+    private localDataSource;
+    eventDataNotify: IPLVEventNotify<EventDataType>;
+    constructor(f180: PLVChannelData);
+    /**
+     * 缓存红包数据
+     * @param redPaperEvent
+     */
+    cacheRedPaper(e180: PLVRedPaperEvent): void;
+    /**
+     * 获取红包数据
+     */
+    getCachedRedPaper(d180: string): PLVRedPaperEvent | undefined;
+    /**
+     * 通过redpackId更新红包状态
+     * @param redpackId
+     * @param receiveType
+     */
+    updateRedPaperReceiveStatus(a180?: string, b180?: RedPaperReceiveType): void;
+    /**
+     * 获取当前红包状态
+     * @param redPaperEvent
+     * @param channelId
+     * @param viewerId
+     */
+    receiveRedPaper(v179: PLVRedPaperEvent, w179?: string, x179?: string): Promise<void>;
+    onRedPaperResultEvent(t179: PLVRedPaperResultEvent): void;
+    /**
+     * 发送当前红包状态
+     * @param delayEvent
+     */
+    notifyPostValue(r179?: PLVRedPaperForDelayEvent): void;
+    /**
+     * 获取本地缓存的红包状态
+     * @param redpackId
+     * @returns
+     */
+    geLocalCachedReceiveStatus(q179?: string): Promise<string>;
+    /**
+     * 更新延迟红包状态
+     * @param channelId
+     */
+    updateDelayRedpackStatus(o179?: string): void;
+    /**
+     * 请求服务端获取红包状态
+     * @param redPackId
+     * @param redpackCacheId
+     * @returns
+     */
+    private getReceiveStatus;
+    /**
+     * 请求服务端获取延迟红包状态
+     * @param channelId
+     * @returns
+     */
+    private getDelayRedpackStatus;
+}

package/src/main/ets/modules/redpack/PLVRedpackManager.js

@@ -0,0 +1,128 @@
+import HashMap from "@ohos.util.HashMap";
+import { apiPlvNetApi } from '../net/PLVApiPlvNetApi';
+import { PLVBaseModule } from '../../common/PLVBaseModule';
+import { PLVEventNotify, PLVJSONUtils, PLVUtils } from '@polyvharmony/live-scenes-foundation';
+import { PLVDelayRedpackStatusVO } from '../interact/redpack/model/PLVDelayRedpackStatusVO';
+import { PLVDelayRedpackVO } from '../interact/redpack/model/PLVDelayRedpackVO';
+import { PLVRedPaperReceiveType } from '../socket/model/redpack/RedPaperReceiveType';
+import { PLVRedpackLocalDataSource } from './database/PLVRedpackLocalDataSource';
+const TAG = '[PLVRedpackManager]';
+export class PLVRedpackManager extends PLVBaseModule {
+    constructor(f180) {
+        super(f180);
+        this.redpackMap = new HashMap();
+        this.localDataSource = PLVRedpackLocalDataSource.getIntance();
+        this.eventDataNotify = new PLVEventNotify(this);
+    }
+    cacheRedPaper(e180) {
+        this.redpackMap.set(e180.redpackId, e180);
+    }
+    getCachedRedPaper(d180) {
+        if (this.redpackMap.hasKey(d180)) {
+            return this.redpackMap.get(d180);
+        }
+        return undefined;
+    }
+    updateRedPaperReceiveStatus(a180, b180) {
+        if (this.channelData.loginChannelId === "" || a180 === "" || b180 === undefined) {
+            return;
+        }
+        const c180 = this.getCachedRedPaper(a180);
+        if (c180 === undefined) {
+            return;
+        }
+        c180.receiveType = b180;
+        this.localDataSource.updateReceiveStatus(c180, this.channelData.loginChannelId, this.channelData.viewerId, b180.value);
+    }
+    async receiveRedPaper(v179, w179, x179) {
+        let y179 = v179.receiveType;
+        if (y179?.value === PLVRedPaperReceiveType.AVAILABLE) {
+            v179.receiveType = PLVRedPaperReceiveType.getValue("AVAILABLE_CLICKED");
+            this.localDataSource.updateReceiveStatus(v179, w179, x179, v179.receiveType.value);
+        }
+        if (y179?.value === PLVRedPaperReceiveType.RECEIVED
+            || y179?.value === PLVRedPaperReceiveType.EXPIRED
+            || y179?.value === PLVRedPaperReceiveType.RUN_OUT) {
+            return;
+        }
+        const value = await this.getReceiveStatus(v179.redpackId, v179.redCacheId);
+        if (value == undefined) {
+            return;
+        }
+        const z179 = PLVRedPaperReceiveType.matchOrDefault(value, PLVRedPaperReceiveType.AVAILABLE);
+        if (z179.value !== PLVRedPaperReceiveType.AVAILABLE) {
+            v179.receiveType = z179;
+            this.localDataSource.updateReceiveStatus(v179, w179, x179, z179.value);
+        }
+    }
+    onRedPaperResultEvent(t179) {
+        if (!t179.isSupportType() || !t179.redpackId) {
+            return;
+        }
+        if (t179.isRedPaperRunOut()) {
+            const u179 = this.getCachedRedPaper(t179.redpackId);
+            if (u179 !== undefined && u179.receiveType?.value === PLVRedPaperReceiveType.AVAILABLE) {
+                u179.receiveType = PLVRedPaperReceiveType.getValue("RUN_OUT");
+                this.localDataSource.updateReceiveStatus(u179, this.channelData.loginChannelId, this.channelData.viewerId, u179.receiveType.value);
+            }
+        }
+    }
+    notifyPostValue(r179) {
+        if (r179 === undefined) {
+            return;
+        }
+        if (!r179?.isSupportType()) {
+            return;
+        }
+        const s179 = new PLVDelayRedpackVO();
+        s179.redpackSendTime = r179.delayTime !== undefined ? r179.delayTime * 1000 + Date.now() : 0;
+        this.eventDataNotify.emit('redpack_data', s179);
+    }
+    async geLocalCachedReceiveStatus(q179) {
+        const status = await this.localDataSource.getReceiveStatus(q179, this.channelData.viewerId);
+        return status;
+    }
+    updateDelayRedpackStatus(o179) {
+        this.getDelayRedpackStatus(o179).then((value) => {
+            this.eventDataNotify.emit('redpack_data', value);
+        });
+    }
+    getReceiveStatus(h179, i179) {
+        return PLVUtils.safePromise(async (k179, l179) => {
+            const m179 = await apiPlvNetApi(this.channelData)
+                .getRedpackReceiveStatus(this.channelData.loginChannelId, this.channelData.appId, this.channelData.viewerId, h179, i179, this.channelData.appSecret)
+                .catch((err) => {
+                return Promise.reject(err.log(TAG, 'getRedpackReceiveStatus error'));
+            });
+            const data = m179.data['data'];
+            const success = m179.data['success'];
+            if (!success) {
+                return Promise.reject(new Error('getRedpackReceiveStatus error'));
+            }
+            k179(data['state']);
+            return;
+        });
+    }
+    getDelayRedpackStatus(z178) {
+        return PLVUtils.safePromise(async (b179, c179) => {
+            const d179 = await apiPlvNetApi(this.channelData)
+                .getDelayRedpackStatus(this.channelData.loginChannelId, this.channelData.appId).catch((err) => {
+                return Promise.reject(err.log(TAG, 'getDelayRedpackStatus error'));
+            });
+            const data = d179.data['data'];
+            const success = d179.data['success'];
+            if (!success) {
+                return Promise.reject(new Error('getDelayRedpackStatus error'));
+            }
+            const e179 = PLVJSONUtils.json2Bean(PLVDelayRedpackStatusVO, PLVJSONUtils.safeStringify(data));
+            const f179 = new PLVDelayRedpackVO();
+            if (e179 === undefined) {
+                return Promise.reject(new Error('getDelayRedpackStatus error'));
+            }
+            f179.redpackSendTime = e179?.sendTime;
+            f179.blessing = e179?.greeting;
+            b179(f179);
+            return;
+        });
+    }
+}

package/src/main/ets/modules/redpack/database/PLVRedpackCacheVO.d.ets

@@ -0,0 +1,9 @@
+export declare class PLVRedpackCacheVO {
+    primaryKey: string;
+    redpackId: string;
+    redCacheId: string;
+    roomId: string;
+    viewerId: string;
+    redPaperReceiveType: string;
+    constructor(primaryKey: string, c178: string, d178: string, e178: string, f178: string, g178: string);
+}

package/src/main/ets/modules/redpack/database/PLVRedpackCacheVO.js

@@ -0,0 +1,47 @@
+var __decorate = (this && this.__decorate) || function (h178, 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(h178, target, key, desc);
+    else
+        for (var i178 = h178.length - 1; i178 >= 0; i178--)
+            if (d = h178[i178])
+                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;
+};
+import { Columns, ColumnType, Entity, Id, NotNull, Unique } from '@ohos/dataorm';
+const REDPACK_TABLE = "plv_redpack_cache_table";
+let PLVRedpackCacheVO = class PLVRedpackCacheVO {
+    constructor(primaryKey, c178, d178, e178, f178, g178) {
+        this.primaryKey = primaryKey;
+        this.redpackId = c178;
+        this.redCacheId = d178;
+        this.roomId = e178;
+        this.viewerId = f178;
+        this.redPaperReceiveType = g178;
+    }
+};
+__decorate([
+    Unique(),
+    NotNull(),
+    Id({ isPrimaryKey: true }),
+    Columns({ columnName: "primaryKey", types: ColumnType.str })
+], PLVRedpackCacheVO.prototype, "primaryKey", void 0);
+__decorate([
+    Columns({ columnName: "redpackId", types: ColumnType.str })
+], PLVRedpackCacheVO.prototype, "redpackId", void 0);
+__decorate([
+    Columns({ columnName: "redCacheId", types: ColumnType.str })
+], PLVRedpackCacheVO.prototype, "redCacheId", void 0);
+__decorate([
+    Columns({ columnName: "roomId", types: ColumnType.str })
+], PLVRedpackCacheVO.prototype, "roomId", void 0);
+__decorate([
+    Columns({ columnName: "viewerId", types: ColumnType.str })
+], PLVRedpackCacheVO.prototype, "viewerId", void 0);
+__decorate([
+    Columns({ columnName: "type", types: ColumnType.str })
+], PLVRedpackCacheVO.prototype, "redPaperReceiveType", void 0);
+PLVRedpackCacheVO = __decorate([
+    Entity(REDPACK_TABLE)
+], PLVRedpackCacheVO);
+export { PLVRedpackCacheVO };

package/src/main/ets/modules/redpack/database/PLVRedpackLocalDataSource.d.ets

@@ -0,0 +1,15 @@
+import { PLVRedPaperEvent } from '../../../modules/interact/redpack/model/PLVRedPaperEvent';
+import { common } from '@kit.AbilityKit';
+export declare class PLVRedpackLocalDataSource {
+    newVersion: number;
+    private DB_NAME;
+    private session;
+    private redPackDao;
+    private static instance;
+    private constructor();
+    static getIntance(): PLVRedpackLocalDataSource;
+    initDB(context: common.UIAbilityContext): Promise<void>;
+    updateReceiveStatus(event: PLVRedPaperEvent, o178?: string, p178?: string, type?: string): Promise<void>;
+    getReceiveStatus(l178?: string, m178?: string): Promise<string>;
+    static createPrimaryKey(j178: string, k178: string): string;
+}

package/src/main/ets/modules/redpack/database/PLVRedpackLocalDataSource.js

@@ -0,0 +1,60 @@
+import { DaoMaster, GlobalContext } from '@ohos/dataorm';
+import { PLVRedpackCacheVO } from './PLVRedpackCacheVO';
+import { PLVRedpackOpenHelper } from './PLVRedpackOpenHelper';
+import { PLVRedPaperReceiveType } from '../../socket/model/redpack/RedPaperReceiveType';
+export class PLVRedpackLocalDataSource {
+    constructor() {
+        this.newVersion = 1;
+        this.DB_NAME = "plv_redpack_cache.db";
+    }
+    static getIntance() {
+        if (!PLVRedpackLocalDataSource.instance) {
+            PLVRedpackLocalDataSource.instance = new PLVRedpackLocalDataSource();
+        }
+        return PLVRedpackLocalDataSource.instance;
+    }
+    async initDB(context) {
+        const q178 = new PLVRedpackOpenHelper(context, this.DB_NAME);
+        q178.setEncrypt(false);
+        await q178.setVersion(this.newVersion);
+        q178.setEntities(PLVRedpackCacheVO);
+        let r178 = await q178.getWritableDb();
+        this.session = new DaoMaster(r178).newSession();
+        this.redPackDao = this.session.getBaseDao(PLVRedpackCacheVO);
+    }
+    async updateReceiveStatus(event, o178, p178, type) {
+        if (!event || !o178 || !p178 || !type) {
+            return;
+        }
+        const primaryKey = PLVRedpackLocalDataSource.createPrimaryKey(event.redpackId, p178);
+        const item = new PLVRedpackCacheVO(primaryKey, event.redpackId, event.redCacheId, o178, p178, type);
+        try {
+            let arr = new Array();
+            arr.push(item);
+            await this.redPackDao?.insertOrReplaceInTxAsync(arr, false);
+        }
+        catch (e) {
+        }
+    }
+    async getReceiveStatus(l178, m178) {
+        if (!this.redPackDao || m178 === undefined || l178 === undefined) {
+            return PLVRedPaperReceiveType.AVAILABLE;
+        }
+        let primaryKey = PLVRedpackLocalDataSource.createPrimaryKey(l178, m178);
+        let n178 = this.redPackDao.queryBuilder();
+        const entityClass = GlobalContext.getContext().getValue(GlobalContext.KEY_CLS);
+        const properties = entityClass.PLVRedpackCacheVO;
+        n178.where(properties['primaryKey'].eq(primaryKey));
+        let list = await n178.list();
+        if (!list || list.length === 0) {
+            return PLVRedPaperReceiveType.AVAILABLE;
+        }
+        if (list[0].redPaperReceiveType === undefined) {
+            return PLVRedPaperReceiveType.AVAILABLE;
+        }
+        return list[0].redPaperReceiveType;
+    }
+    static createPrimaryKey(j178, k178) {
+        return j178 + "_" + k178;
+    }
+}

package/src/main/ets/modules/redpack/database/PLVRedpackOpenHelper.d.ets

@@ -0,0 +1,8 @@
+import { Database, OpenHelper } from '@ohos/dataorm';
+import { common } from '@kit.AbilityKit';
+export declare class PLVRedpackOpenHelper extends OpenHelper {
+    constructor(context: common.UIAbilityContext, name: string, customDir?: string);
+    onCreateDatabase(y178: Database): Promise<void>;
+    onUpgradeDatabase(v178: Database, w178: number, x178: number): Promise<void>;
+    onDowngradeDatabase(s178: Database, t178: number, u178: number): Promise<void>;
+}

package/src/main/ets/modules/redpack/database/PLVRedpackOpenHelper.js

@@ -0,0 +1,15 @@
+import { OpenHelper } from '@ohos/dataorm';
+export class PLVRedpackOpenHelper extends OpenHelper {
+    constructor(context, name, customDir) {
+        super(context, name, customDir);
+    }
+    async onCreateDatabase(y178) {
+        super.onCreateDatabase(y178);
+    }
+    onUpgradeDatabase(v178, w178, x178) {
+        return Promise.resolve();
+    }
+    onDowngradeDatabase(s178, t178, u178) {
+        return Promise.resolve();
+    }
+}