@ledvance/base 1.0.1

package/src/main.tsx

@@ -0,0 +1,9 @@
+import {createNavigator, GlobalTheme, NavigationRoute} from 'tuya-panel-kit'
+import composeLayout from './composeLayout'
+
+export function Navigation(router: NavigationRoute[]) {
+    return composeLayout(createNavigator<{ theme: GlobalTheme }>({
+        router: router,
+        screenOptions: {},
+    }))
+}

package/src/models/GlobalParams.d.ts

@@ -0,0 +1,14 @@
+interface DpSchemaProperty extends Record<string, any> {
+    type: string;
+}
+export interface DpSchema {
+    name: string;
+    dp: number;
+    type: string;
+    mode: string;
+    property: DpSchemaProperty;
+}
+export declare class GlobalParams {
+    static dpSchemaMap: Record<string, DpSchema>;
+}
+export {};

package/src/models/GlobalParams.ts

@@ -0,0 +1,15 @@
+interface DpSchemaProperty extends Record<string, any> {
+    type: string
+}
+
+export interface DpSchema {
+    name: string
+    dp: number
+    type: string
+    mode: string
+    property: DpSchemaProperty
+}
+
+export class GlobalParams {
+    static dpSchemaMap: Record<string, DpSchema> = {}
+}

package/src/models/TuyaApi.d.ts

@@ -0,0 +1,17 @@
+export interface PagingResult<T> {
+    data: T;
+    hasNext: boolean;
+    currentOffset: number;
+}
+export interface DpReportSataResData {
+    dps: DpReportSataData[];
+    hasNext: boolean;
+    total: number;
+}
+export interface DpReportSataData {
+    timeStamp: number;
+    dpId: number;
+    timeStr: string;
+    value: string;
+}
+export declare function getDpReportSataData(deviceId: string, dpIds: string[], offset: number, limit: number, sortType?: 'ASC' | 'DESC'): Promise<DpReportSataResData>;

package/src/models/TuyaApi.ts

@@ -0,0 +1,37 @@
+import {commonApi} from '@tuya/tuya-panel-api'
+
+export interface PagingResult<T> {
+    data: T
+    hasNext: boolean
+    currentOffset: number
+}
+
+export interface DpReportSataResData {
+    dps: DpReportSataData[]
+    hasNext: boolean
+    total: number
+}
+
+export interface DpReportSataData {
+    timeStamp: number
+    dpId: number
+    timeStr: string
+    value: string
+}
+
+export async function getDpReportSataData(
+    deviceId: string,
+    dpIds: string[],
+    offset: number,
+    limit: number,
+    sortType?: 'ASC' | 'DESC',
+): Promise<DpReportSataResData> {
+    const params = {
+        devId: deviceId,
+        dpIds: dpIds.join(','),
+        offset: offset,
+        limit: limit,
+        sortType: sortType || 'DESC',
+    }
+    return commonApi.statApi.getDpReportLog(params)
+}

package/src/models/combine.d.ts

@@ -0,0 +1,26 @@
+export declare const reducers: {
+    dpState: import("redux-actions").ReduxCompatibleReducer<import("./modules/common").DpState, import("tuya-panel-kit").DevInfo<Record<string, import("tuya-panel-kit").DpType>> | (Partial<import("./modules/common").DpState> & {
+        [key: string]: string | number | boolean;
+    })>;
+    devInfo: import("redux-actions").ReduxCompatibleReducer<import("tuya-panel-kit").DevInfo<import("./modules/common").DpState>, import("tuya-panel-kit").DevInfo<import("./modules/common").DpState>>;
+    logs: import("redux-actions").ReduxCompatibleReducer<import("./modules/common").Log[], import("tuya-panel-kit").DevInfo<Record<string, import("tuya-panel-kit").DpType>> | (Partial<import("./modules/common").DpState> & {
+        [key: string]: string | number | boolean;
+    }) | undefined>;
+    ldvModules: import("@reduxjs/toolkit").Reducer<import("./modules/NativePropsSlice").NativeProps, import("@reduxjs/toolkit").AnyAction>;
+};
+declare type Reducers = typeof reducers;
+export declare type ReduxState = {
+    [K in keyof Reducers]: ReturnType<Reducers[K]>;
+};
+export declare const rootReducers: import("redux").Reducer<import("redux").CombinedState<{
+    dpState: import("./modules/common").DpState;
+    devInfo: import("tuya-panel-kit").DevInfo<import("./modules/common").DpState>;
+    logs: import("./modules/common").Log[];
+    ldvModules: import("./modules/NativePropsSlice").NativeProps;
+}>, import("redux").AnyAction>;
+export declare const rootEpics: import("redux-observable").Epic<import("redux-actions").Action<Partial<import("./modules/common").DpState> & {
+    [key: string]: string | number | boolean;
+}>, import("redux-actions").Action<Partial<import("./modules/common").DpState> & {
+    [key: string]: string | number | boolean;
+}>, void, any>;
+export {};

package/src/models/combine.ts

@@ -0,0 +1,17 @@
+import { combineReducers } from 'redux';
+import { combineEpics } from 'redux-observable';
+import { reducers as commonReducers, epics as commonEpics } from './modules/common';
+
+export const reducers = {
+  ...commonReducers,
+};
+
+type Reducers = typeof reducers;
+
+export type ReduxState = { [K in keyof Reducers]: ReturnType<Reducers[K]> };
+
+export const rootReducers = combineReducers(reducers);
+
+const allEpics = [...commonEpics];
+
+export const rootEpics = combineEpics(...allEpics);

package/src/models/configureStore.d.ts

@@ -0,0 +1,9 @@
+import { ReduxState } from './combine';
+export default function configureStore(initialState?: Partial<ReduxState>): import("redux").Store<import("redux").CombinedState<{
+    dpState: import("./modules/common").DpState;
+    devInfo: import("tuya-panel-kit").DevInfo<import("./modules/common").DpState>;
+    logs: import("./modules/common").Log[];
+    ldvModules: import("./modules/NativePropsSlice").NativeProps;
+}>, import("redux").AnyAction> & {
+    dispatch: unknown;
+};

package/src/models/configureStore.ts

@@ -0,0 +1,33 @@
+import {applyMiddleware, compose, createStore} from 'redux'
+import {createLogger} from 'redux-logger'
+import {createEpicMiddleware} from 'redux-observable'
+import {ReduxState, rootEpics, rootReducers} from './combine'
+
+const epicMiddleware = createEpicMiddleware()
+
+const mWindow: any = window
+
+const isDebuggingInChrome = __DEV__ && !!mWindow.navigator.userAgent
+const logger = createLogger({
+    predicate: () => isDebuggingInChrome,
+    collapsed: true,
+    duration: true,
+})
+
+const middleware = isDebuggingInChrome ? [epicMiddleware, logger] : [epicMiddleware]
+
+export default function configureStore(initialState?: Partial<ReduxState>) {
+    const appliedMiddleware = applyMiddleware(...middleware)
+
+    const store = createStore(
+        rootReducers,
+        initialState,
+        compose(
+            appliedMiddleware,
+            isDebuggingInChrome && mWindow.devToolsExtension ? mWindow.devToolsExtension() : (f: any) => f,
+        ),
+    )
+
+    epicMiddleware.run(rootEpics)
+    return store
+}

package/src/models/index.d.ts

@@ -0,0 +1,31 @@
+import { ReduxState } from './combine';
+export * from './combine';
+export * from './configureStore';
+declare const actions: {
+    common: {
+        devInfoChange: import("redux-actions").ActionFunction1<import("tuya-panel-kit").DevInfo<Record<string, import("tuya-panel-kit").DpType>>, import("redux-actions").Action<import("tuya-panel-kit").DevInfo<Record<string, import("tuya-panel-kit").DpType>>>>;
+        deviceChange: import("redux-actions").ActionFunction1<import("tuya-panel-kit").DevInfo<Record<string, import("tuya-panel-kit").DpType>>, import("redux-actions").Action<import("tuya-panel-kit").DevInfo<Record<string, import("tuya-panel-kit").DpType>>>>;
+        responseUpdateDp: import("redux-actions").ActionFunction1<Partial<import("./modules/common").DpState> & {
+            [key: string]: string | number | boolean;
+        }, import("redux-actions").Action<Partial<import("./modules/common").DpState> & {
+            [key: string]: string | number | boolean;
+        }>>;
+        updateDp: import("redux-actions").ActionFunction1<Partial<import("./modules/common").DpState> & {
+            [key: string]: string | number | boolean;
+        }, import("redux-actions").Action<Partial<import("./modules/common").DpState> & {
+            [key: string]: string | number | boolean;
+        }>>;
+        consoleChange: import("redux-actions").ActionFunctionAny<import("redux-actions").Action<any>>;
+        clearConsole: import("redux-actions").ActionFunctionAny<import("redux-actions").Action<any>>;
+    };
+};
+export { actions };
+export declare const store: import("redux").Store<import("redux").CombinedState<{
+    dpState: import("./modules/common").DpState;
+    devInfo: import("tuya-panel-kit").DevInfo<import("./modules/common").DpState>;
+    logs: import("./modules/common").Log[];
+    ldvModules: import("./modules/NativePropsSlice").NativeProps;
+}>, import("redux").AnyAction> & {
+    dispatch: unknown;
+};
+export declare function useSelector<TSelected>(selector: (state: ReduxState) => TSelected, equalityFn?: (left: TSelected, right: TSelected) => boolean): TSelected;

package/src/models/index.ts

@@ -0,0 +1,22 @@
+import {shallowEqual, useSelector as useSelectorBase} from 'react-redux'
+import {actions as CommonActions} from './modules/common'
+import {ReduxState} from './combine'
+import configureStore from './configureStore'
+
+export * from './combine'
+export * from './configureStore'
+
+const actions = {
+    common: CommonActions,
+}
+
+export {actions}
+
+export const store = configureStore()
+
+export function useSelector<TSelected>(
+    selector: (state: ReduxState) => TSelected,
+    equalityFn?: (left: TSelected, right: TSelected) => boolean,
+) {
+    return useSelectorBase<ReduxState, TSelected>(selector, equalityFn || shallowEqual)
+}

package/src/models/modules/NativePropsSlice.d.ts

@@ -0,0 +1,25 @@
+import { Dispatch } from 'react';
+import { Result } from './Result';
+import { DevInfo, DpValue } from 'tuya-panel-kit';
+export interface NativeProps {
+    devId: string;
+    pId: string;
+    dps: any;
+    familyName: string;
+    timeSchedule?: symbol;
+}
+declare function simpleSetDps<T>(dispatch: Dispatch<any>): (deviceId: string, dps: any) => Promise<Result<T>>;
+declare function simpleSetDp<T>(dispatch: Dispatch<any>): (deviceId: string, dp: string, value: any) => Promise<Result<T>>;
+declare const useDeviceId: () => string;
+declare const useFamilyName: () => string;
+declare function useDp<T, R>(dp: string): [T, (value: T) => Promise<Result<R>>];
+declare function useDps<R>(): [any, (dps: any) => Promise<Result<R>>];
+interface DpState {
+    switch: boolean;
+    [dpCode: string]: DpValue;
+}
+declare const useDeviceInfo: () => DevInfo<DpState>;
+declare const useTimeSchedule: () => symbol | undefined;
+export declare const ldvModules: import("@reduxjs/toolkit").Reducer<NativeProps, import("@reduxjs/toolkit").AnyAction>;
+export declare const setNativeProps: import("@reduxjs/toolkit").ActionCreatorWithPayload<NativeProps, string>, setDps: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, setTimeSchedule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export { simpleSetDps, simpleSetDp, useDeviceId, useDeviceInfo, useDp, useDps, useFamilyName, useTimeSchedule, };

package/src/models/modules/NativePropsSlice.tsx

@@ -0,0 +1,145 @@
+import {createSlice, PayloadAction} from '@reduxjs/toolkit'
+import {useSelector} from '../index'
+import {Dispatch, useCallback} from 'react'
+import {DpsResult, Result} from './Result'
+import {DevInfo, DpValue} from 'tuya-panel-kit'
+import {NativeApi} from '../../api/native'
+import {useDispatch} from 'react-redux'
+
+export interface NativeProps {
+    devId: string,
+    pId: string,
+    dps: any,
+    familyName: string,
+    timeSchedule?: symbol;
+}
+
+const initialState: NativeProps = {
+    devId: '',
+    pId: '',
+    dps: {},
+    familyName: '',
+    timeSchedule: Symbol(),
+}
+
+const nativePropsSlice = createSlice({
+    name: 'ldvModules',
+    initialState: initialState,
+    reducers: {
+        setNativeProps: (state, action: PayloadAction<NativeProps>) => {
+            state.devId = action.payload.devId
+            if (!!action.payload.familyName) {
+                state.familyName = action.payload.familyName
+            }
+            if (!!action.payload.pId) {
+                state.pId = action.payload.pId
+            }
+            state.dps = {...state.dps, ...action.payload.dps}
+        },
+        setDps(state, action: PayloadAction<any>) {
+            const dpKeys = Object.keys(action.payload)
+            dpKeys.forEach(dp => {
+                state.dps[dp] = action.payload[dp]
+            })
+        },
+        setTimeSchedule(state, action: PayloadAction<any>) {
+            state.timeSchedule = action.payload.timeSchedule
+        },
+    },
+})
+
+type AsyncBlockType<T> = () => Promise<DpsResult<T>>
+type SyncBlockType<T> = () => DpsResult<T>
+
+function asyncSetDps<T>(dispatch: Dispatch<any>, block: AsyncBlockType<T> | SyncBlockType<T>): Promise<Result<T>> {
+    return new Promise<Result<T>>(async (res, _rej) => {
+        const dpsResult = await block()
+        if (dpsResult.result.success) {
+            // 只在结果成功时才改变 redux 数据
+            dispatch(setDps(dpsResult.dps))
+        }
+        res(dpsResult.result)
+    })
+}
+
+function simpleSetDps<T>(dispatch: Dispatch<any>): (deviceId: string, dps: any) => Promise<Result<T>> {
+    return (deviceId, dps) => {
+        return asyncSetDps(dispatch, async () => {
+            console.log('发送dp数据：', deviceId, JSON.stringify(dps))
+            const res = await NativeApi.setDps(deviceId, dps)
+            if (res.result) {
+                return {
+                    result: {success: true},
+                    dps: dps,
+                }
+            }
+            return {
+                result: {success: false, msg: res.msg},
+            }
+        })
+    }
+}
+
+function simpleSetDp<T>(dispatch: Dispatch<any>): (deviceId: string, dp: string, value: any) => Promise<Result<T>> {
+    return (deviceId, dp, value) => {
+        const fun = simpleSetDps<T>(dispatch)
+        return fun(deviceId, {[dp]: value})
+    }
+}
+
+const useDeviceId = () => {
+    return useSelector(store => store.ldvModules.devId)
+}
+
+const useFamilyName: () => string = () => {
+    return useSelector(store => store.ldvModules.familyName)
+}
+
+function useDp<T, R>(dp: string): [T, (value: T) => Promise<Result<R>>] {
+    const deviceId = useDeviceId()
+    const dispatch = useDispatch()
+    const dpValue = useSelector(store => store.ldvModules.dps[dp])
+    const setDp = useCallback((dpValue: T) => {
+        return simpleSetDp<R>(dispatch)(deviceId, dp, dpValue)
+    }, [])
+    return [dpValue, setDp]
+}
+
+function useDps<R>(): [any, (dps: any) => Promise<Result<R>>] {
+    const deviceId = useDeviceId()
+    const dispatch = useDispatch()
+    const dps = useSelector(store => store.ldvModules.dps)
+    const setDps = useCallback((dps: any) => {
+        return simpleSetDps<R>(dispatch)(deviceId, dps)
+    }, [])
+    return [dps, setDps]
+}
+
+interface DpState {
+    switch: boolean;
+
+    [dpCode: string]: DpValue;
+}
+
+const useDeviceInfo: () => DevInfo<DpState> = () => {
+    return useSelector(state => state.devInfo)
+}
+
+const useTimeSchedule = () => {
+    return useSelector(store => store.ldvModules.timeSchedule)
+}
+
+export const ldvModules = nativePropsSlice.reducer
+
+export const {setNativeProps, setDps, setTimeSchedule} = nativePropsSlice.actions
+
+export {
+    simpleSetDps,
+    simpleSetDp,
+    useDeviceId,
+    useDeviceInfo,
+    useDp,
+    useDps,
+    useFamilyName,
+    useTimeSchedule,
+}

package/src/models/modules/Result.d.ts

@@ -0,0 +1,14 @@
+export interface Result<T> {
+    success: boolean;
+    data?: T | undefined;
+    msg?: string | undefined;
+}
+export interface DpsResult<T> {
+    result: Result<T>;
+    dps?: any | undefined;
+}
+export interface NativeResult<T> {
+    result: boolean;
+    data?: T;
+    msg?: string;
+}

package/src/models/modules/Result.ts

@@ -0,0 +1,16 @@
+export interface Result<T> {
+    success: boolean;
+    data?: T | undefined,
+    msg?: string | undefined
+}
+
+export interface DpsResult<T> {
+    result: Result<T>,
+    dps?: any | undefined
+}
+
+export interface NativeResult<T> {
+    result: boolean
+    data?: T
+    msg?: string
+}

package/src/models/modules/common.d.ts

@@ -0,0 +1,44 @@
+import { DevInfo, DpValue } from 'tuya-panel-kit';
+import { Observable } from 'rxjs/Observable';
+import { ActionsObservable } from 'redux-observable';
+import 'rxjs/add/observable/fromPromise';
+import 'rxjs/add/observable/of';
+import 'rxjs/add/observable/merge';
+import 'rxjs/add/operator/catch';
+import 'rxjs/add/operator/map';
+import 'rxjs/add/operator/mergeMap';
+import 'rxjs/add/operator/partition';
+export interface DpState {
+    switch: boolean;
+    [dpCode: string]: DpValue;
+}
+export interface Log {
+    strCodes: string;
+    strIds: string;
+    time: string;
+    isSend: boolean;
+}
+declare type Logs = Array<Log>;
+declare type UpdateDevInfoPayload = DevInfo;
+declare type UpdateDpStatePayload = Partial<DpState> & {
+    [key: string]: DpValue;
+};
+export declare const actions: {
+    devInfoChange: import("redux-actions").ActionFunction1<UpdateDevInfoPayload, import("redux-actions").Action<UpdateDevInfoPayload>>;
+    deviceChange: import("redux-actions").ActionFunction1<UpdateDevInfoPayload, import("redux-actions").Action<UpdateDevInfoPayload>>;
+    responseUpdateDp: import("redux-actions").ActionFunction1<UpdateDpStatePayload, import("redux-actions").Action<UpdateDpStatePayload>>;
+    updateDp: import("redux-actions").ActionFunction1<UpdateDpStatePayload, import("redux-actions").Action<UpdateDpStatePayload>>;
+    consoleChange: import("redux-actions").ActionFunctionAny<import("redux-actions").Action<any>>;
+    clearConsole: import("redux-actions").ActionFunctionAny<import("redux-actions").Action<any>>;
+};
+export declare type Actions = {
+    [K in keyof typeof actions]: ReturnType<typeof actions[K]>;
+};
+export declare const reducers: {
+    dpState: import("redux-actions").ReduxCompatibleReducer<DpState, UpdateDevInfoPayload | UpdateDpStatePayload>;
+    devInfo: import("redux-actions").ReduxCompatibleReducer<DevInfo<DpState>, DevInfo<DpState>>;
+    logs: import("redux-actions").ReduxCompatibleReducer<Logs, DevInfo<Record<string, import("tuya-panel-kit").DpType>> | UpdateDpStatePayload | undefined>;
+    ldvModules: import("@reduxjs/toolkit").Reducer<import("./NativePropsSlice").NativeProps, import("@reduxjs/toolkit").AnyAction>;
+};
+export declare const epics: ((action$: ActionsObservable<Actions['updateDp']>) => Observable<import("redux-actions").Action<UpdateDpStatePayload>>)[];
+export {};

package/src/models/modules/common.ts

@@ -0,0 +1,161 @@
+import {DevInfo, DpValue, TYSdk} from 'tuya-panel-kit'
+import {createAction, handleActions} from 'redux-actions'
+import {Observable} from 'rxjs/Observable'
+import {ActionsObservable} from 'redux-observable'
+import 'rxjs/add/observable/fromPromise'
+import 'rxjs/add/observable/of'
+import 'rxjs/add/observable/merge'
+import 'rxjs/add/operator/catch'
+import 'rxjs/add/operator/map'
+import 'rxjs/add/operator/mergeMap'
+import 'rxjs/add/operator/partition'
+import {ldvModules} from './NativePropsSlice'
+
+const {putDeviceData} = TYSdk.device
+
+export interface DpState {
+    switch: boolean;
+
+    [dpCode: string]: DpValue;
+}
+
+export interface Log {
+    strCodes: string;
+    strIds: string;
+    time: string;
+    isSend: boolean;
+}
+
+type Logs = Array<Log>;
+
+type UpdateDevInfoPayload = DevInfo;
+type UpdateDpStatePayload = Partial<DpState> & { [key: string]: DpValue }; // 保证起码有一个键值对存在
+
+/**
+ * actions
+ */
+const devInfoChange = createAction<UpdateDevInfoPayload>('_DEVINFOCHANGE_')
+const deviceChange = createAction<UpdateDevInfoPayload>('_DEVICECHANGED_')
+const responseUpdateDp = createAction<UpdateDpStatePayload>('RESPONSE_UPDATE_DP')
+const updateDp = createAction<UpdateDpStatePayload>('CHANGE_DP')
+const consoleChange = createAction('CONSOLECHNAGE')
+const clearConsole = createAction('CLEARCONSOLE')
+
+export const actions = {
+    devInfoChange,
+    deviceChange,
+    responseUpdateDp,
+    updateDp,
+    consoleChange,
+    clearConsole,
+}
+
+export type Actions = { [K in keyof typeof actions]: ReturnType<typeof actions[K]> };
+
+/**
+ * reducers
+ */
+const dpState = handleActions<DpState, UpdateDpStatePayload | UpdateDevInfoPayload>(
+    {
+        [devInfoChange.toString()]: (state, action: Actions['devInfoChange']) => {
+            return {
+                ...state,
+                ...action.payload.state,
+            }
+        },
+
+        [responseUpdateDp.toString()]: (state, action: Actions['responseUpdateDp']) => ({
+            ...state,
+            ...action.payload,
+        }),
+    },
+    {} as DpState,
+)
+
+const devInfo = handleActions<DevInfo<DpState>>(
+    {
+        [devInfoChange.toString()]: (state, action) => ({
+            ...state,
+            ...action.payload,
+        }),
+
+        [deviceChange.toString()]: (state, action) => ({
+            ...state,
+            ...action.payload,
+        }),
+    },
+    {} as DevInfo<DpState>,
+)
+
+let isSend = false
+
+const formatLogs = (state: Logs, action: { payload: UpdateDpStatePayload }, send: boolean) => {
+    const ret = Object.keys(action.payload).reduce((obj, p) => {
+        const id = TYSdk.device.getDpIdByCode(p)
+        return {...obj, [id]: action.payload[p]}
+    }, {})
+    const strIds = JSON.stringify(ret, null, 2)
+    const strCodes = JSON.stringify(action.payload, null, 2)
+    const date = new Date()
+    const time = `[${[
+        date.getHours(),
+        date.getMinutes(),
+        date.getSeconds(),
+        date.getMilliseconds(),
+    ].join(':')}]`
+    const s = [{strCodes, strIds, time, isSend: send}, ...state]
+    return s.slice(0, 30)
+}
+
+const logs = handleActions<Logs, undefined | UpdateDpStatePayload | DevInfo>(
+    {
+        [consoleChange.toString()]: state => {
+            isSend = true
+            return state
+        },
+
+        [updateDp.toString()]: (state, action: Actions['updateDp']) => {
+            isSend = true
+            return formatLogs(state, action, isSend)
+        },
+
+        [devInfoChange.toString()]: (state, action: Actions['devInfoChange']) => {
+            const formatAction = {payload: action.payload.state}
+            return formatLogs(state, formatAction, isSend)
+        },
+
+        [responseUpdateDp.toString()]: (state, action: Actions['responseUpdateDp']) => {
+            isSend = false
+            return formatLogs(state, action, isSend)
+        },
+
+        [clearConsole.toString()]: () => [],
+    },
+    [],
+)
+
+export const reducers = {
+    dpState,
+    devInfo,
+    logs,
+    ldvModules,
+}
+
+/**
+ * epics
+ */
+const dpUpdateEpic$ = (action$: ActionsObservable<Actions['updateDp']>) => {
+    return action$.ofType(updateDp.toString()).mergeMap(action => {
+        const {payload} = action
+        const [success, error] = Observable.fromPromise(putDeviceData(payload))
+            .catch(() => Observable.of(responseUpdateDp({})))
+            .partition((x: { success: boolean }) => x.success)
+
+        return Observable.merge(
+            success.map(() => responseUpdateDp(payload)), // 如果每次操作都必须等到上报以后再更新，可以注释掉本段代码
+            error.map(() => responseUpdateDp({})),
+        )
+    })
+}
+
+export const epics = [dpUpdateEpic$]