processor/instances/InstanceExpandHelper.ets

/**
 * @file Describe the file
 * Copyright (c) 2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import data_rdb from '@ohos.data.rdb'
import { EventColumns } from '@ohos/datastructure/src/main/ets/events/EventColumns'
import { Events } from '@ohos/datastructure/src/main/ets/events/Events'
import { EventIndexes, parseIndexes } from '@ohos/datastructure/src/main/ets/events/EventIndexes'
import { parseEvents } from '@ohos/datastructure/src/main/ets/events/EventParser'
import { InstancesColumns } from '@ohos/datastructure/src/main/ets/instances/InstancesColumns'
import { RecurrenceSet } from '@ohos/rrule/src/main/ets/RecurrenceSet'
import { Log } from '@ohos/common/src/main/ets/utils/Log'
import { getJulianDayByMills } from '@ohos/common/src/main/ets/time/JulianDay'
import { getMinutesByMills, HOURS_PER_DAY, MINUTES_PER_HOUR } from '@ohos/common/src/main/ets/utils/TimeUtils'

const TAG = "InstanceExpandHelper"

/**
 * 删除所有Instances
 * 如时区变化等场景，需要清空后重新扩展
 */
export async function deleteAllInstances(rdbStore): Promise<boolean> {
  const predicate = new data_rdb.RdbPredicates(InstancesColumns.TABLE_NAME)
  const result = await rdbStore.delete(predicate)
  return result >= 0
}

/**
 * 按时间范围扩展所有Instances
 *
 * @param beginTime 开始时间
 * @param end 结束时间
 */
export async function expandAllByRange(rdbStore, beginTime: number, endTime: number): Promise<boolean> {
  Log.info(TAG, `expandAllByRange called: ${beginTime}, ${endTime}, rdbStore=${rdbStore}`)
  const queryPredicates = new data_rdb.RdbPredicates(EventColumns.TABLE_NAME)
  queryPredicates.between(EventColumns.DTSTART, beginTime, endTime)
  const columns = [EventColumns.ID, EventColumns.TITLE, EventColumns.DTSTART, EventColumns.DTEND, EventColumns.CREATOR]
  const resultSet = await rdbStore.query(queryPredicates, columns)
  Log.debug(TAG, `expandAllByRange query callback: ${resultSet}`)
  if (resultSet !== null && resultSet !== undefined) {
    if (resultSet.rowCount <= 0) {
      Log.info(TAG, `expandAllByRange ${beginTime}/${endTime} no event to be expand`)
      return true
    }
    return await expandInstancesByResultSet(rdbStore, resultSet)
  }
  Log.warn(TAG, "expandAllByRange end with empty cursor")
  return false
}

/**
 * 扩展单个日程的Instances
 *
 * @param eventId 日程ID
 * @param beginTime 开始时间
 * @param endTime 结束时间
 */
export function expandOneInRange(rdbStore, event: Events, expandedBegin: number, expandedEnd: number): boolean {
  if (event === null || event === undefined) {
    Log.warn(TAG, 'expandOneInRange get invalid params');
    return false;
  }
  Log.info(TAG, `expandOneInRange id=${event.id}, range=${expandedBegin}/${expandedEnd}`);
  const instancesMap: InstancesMap = new InstancesMap();
  const rruleSet: RecurrenceSet = new RecurrenceSet(event.rRule, event.rDate, event.exRule, event.exDate);
  const date = new Date();
  if (rruleSet.hasRecurrence()) {
    Log.warn(TAG, "generateInstancesMapFromValues not support rrule event yet");
  } else {
    if (event.dtStart > expandedEnd || event.dtEnd < expandedBegin) {
      Log.debug(TAG, `expandOneInRange not in expandedRange:${event.dtStart}/${event.dtEnd}`);
      return true;
    }
    const contentValues: data_rdb.ValuesBucket = getContentValuesFromEvent(date, event);
    const syncIdKey = event.calendarId + "_" + event.id;
    instancesMap.pushInstances(syncIdKey, contentValues);
  }
  if (instancesMap !== null && instancesMap !== undefined) {
    batchInsertInstances(rdbStore, instancesMap);
    return true;
  }
  return false;
}

/**
 * 扩展单个日程的Instances
 *
 * @param eventId 日程ID
 * @param beginTime 开始时间
 * @param endTime 结束时间
 */
export function expandAllByPredicates(rdbStore, eventId: number, expandedBegin: number, expandedEnd: number): boolean {
  return false
}

/**
 * 根据数据库查询的ResultSet扩展生成Instances并插入数据库
 *
 * @param rdbStore 数据库实例
 * @param resultSet Events表查询到的结果
 * @return true 处理成功 false 处理失败
 */
async function expandInstancesByResultSet(rdbStore: data_rdb.RdbStore, resultSet): Promise<boolean> {
  Log.debug(TAG, 'expandInstancesByResultSet generateInstancesMap begin')
  const instancesMap = generateInstancesMapFromValues(resultSet)
  Log.debug(TAG, `expandInstancesByResultSet generateInstancesMap end: ${instancesMap}`)
  if (instancesMap !== null && instancesMap !== undefined) {
    return await batchInsertInstances(rdbStore, instancesMap)
  }
  Log.warn(TAG, 'expandInstancesByResultSet maybe occurs some error')
  return false
}

/**
 * 根据日程信息，生成待插入的Instances列表数据
 * 如果是重复日程，则列表中含多个Instances数据
 * 如果不是重复日程，则列表中只含一个Instances数据
 *
 * @param resultSet db.query结果集
 */
function generateInstancesMapFromValues(resultSet): InstancesMap {
  const moveToFirstSuccessful: boolean = resultSet.goToFirstRow()
  if (!moveToFirstSuccessful) {
    Log.error(TAG, "generateInstancesMapFromValues move to first failed")
    return undefined
  }
  const instancesMap: InstancesMap = new InstancesMap()
  const indexes: EventIndexes = parseIndexes(resultSet)
  let event: Events
  const date: Date = new Date()
  do {
    event = parseEvents(resultSet, indexes)
    if (event === null || event === undefined) {
      continue
    }
    const rruleSet: RecurrenceSet = new RecurrenceSet(event.rRule, event.rDate, event.exRule, event.exDate)
    if (rruleSet.hasRecurrence()) {
      Log.warn(TAG, "generateInstancesMapFromValues not support rrule event yet")
    }
    const contentValues: data_rdb.ValuesBucket = getContentValuesFromEvent(date, event)
    const syncIdKey = event.calendarId + "_" + event.id
    instancesMap.pushInstances(syncIdKey, contentValues)
  } while (resultSet.goToNextRow())
  return instancesMap
}

/**
 * 根据Event数据生成Instances数据
 *
 * @param event Event数据
 */
function getContentValuesFromEvent(date: Date, event: Events): data_rdb.ValuesBucket {
  const startDay = getJulianDayByMills(date, event.dtStart)
  let endDay = getJulianDayByMills(date, event.dtEnd)
  const startMinute = getMinutesByMills(date, event.dtStart)
  let endMinute = getMinutesByMills(date, event.dtEnd)

  // 午夜的特殊情况，当endMinute == 0.将前一天更改为+24小时
  // Exception: 如果startMinute和endMinute在同一天都为0,只留下endMinute.
  if (endMinute == 0 && endDay > startDay) {
    endMinute = HOURS_PER_DAY * MINUTES_PER_HOUR;
    endDay -= 1;
  }
  return {
    [InstancesColumns.EVENT_ID]: event.id,
    [InstancesColumns.BEGIN]: event.dtStart,
    [InstancesColumns.END]: event.dtEnd,
    [InstancesColumns.START_DAY]: startDay,
    [InstancesColumns.END_DAY]: endDay,
    [InstancesColumns.START_MINUTE]: startMinute,
    [InstancesColumns.END_MINUTE]: endMinute,
    [InstancesColumns.CREATOR]: event.creator
  }
}

async function batchInsertInstances(rdbStore: data_rdb.RdbStore, instancesMap: InstancesMap): Promise<boolean> {
  Log.debug(TAG, `batchInsertInstances begin`)
  for (let valuesList of instancesMap.values()) {
    for (let contentValues of valuesList) {
      Log.debug(TAG, `InsertInstances begin: ${instancesValuesToString(contentValues)}`)
      try {
        const rowId = await rdbStore.insert(InstancesColumns.TABLE_NAME, contentValues)
        if (rowId < 0) {
          Log.warn(TAG, `InsertInstances failed ${instancesValuesToString(contentValues)}`)
          return false
        }
      } catch (err) {
        // 当eventId、begin、end三个字段与表中已有数据一致时，产生表约束冲突会抛出异常，此报错可忽略
        // 为不影响其他Instances插入try-catch保护一下
        Log.error(TAG, `InsertInstances get err:${err}`)
      }
      Log.debug(TAG, `InsertInstances end: ${instancesValuesToString(contentValues)}`)
    }
  }
  Log.debug(TAG, `batchInsertInstances successful`)
  return true
}

function instancesValuesToString(values): string {
  return `eventId=${values.event_id},begin=${values.begin},end=${values.end}, startDay=${values.startDay}`
  + `,endDay=${values.endDay},startMinute=${values.startMinute},endMinute=${values.endMinute}`
}

/**
 * 存放Instances的集合Map
 *
 * @since 2022-05-28
 */
class InstancesMap extends Map<string, Array<data_rdb.ValuesBucket>> {
  /**
   * 以syncIdKey为key，将Instances对应的ValuesBucket放入集合Map中
   * 注：每个key对应一个Instances列表
   *
   * @param syncIdKey Map集合分类的key
   * @param values ValuesBucket数据，由此生成Instances实例
   */
  pushInstances(syncIdKey: string, values: data_rdb.ValuesBucket) {
    let instancesList: Array<data_rdb.ValuesBucket> = undefined
    if (this.has(syncIdKey)) {
      instancesList = this.get(syncIdKey)
    }
    if (instancesList === null || instancesList === undefined) {
      instancesList = new Array<data_rdb.ValuesBucket>()
      this.set(syncIdKey, instancesList)
    }
    instancesList.push(values)
  }
}