- Application
    - AppScope
        app.json5    // 应用的全局配置信息
    - entry           // 应用/服务模块，编译构建生成一个HAP
        oh_modules   // 用于存放三方库依赖信息
        - src/main
            - ets    // 用于存放ArkTS源码
            - resources    // 用于存放应用/服务所用到的资源文件
            module.json5    // Stage模型配置文件
        build-profile.json5    // 当前模块信息、编译信息配置项
        hvigorfile.ts          // 模块级编译构建任务脚本
        oh-package.json5        // 配置三方包声明的入口及包名
    build-profile.json5    // 应用配置信息，包括签名、产品配置等
    hvigorfile.ts          // 应用级编译构建任务脚本

- CloudProgram
    - clouddb    // 云数据库工程目录
        dataentry    // 用于存放数据条目文件
        objecttype    // 用于存放对象类型文件
        db-config.json    // 模块配置文件
    - cloudfunctions    // 云函数工程目录
        cloudFunctionName // 云函数名称
          node_modules    // 包含所有三方依赖
          cloud-config.json    // 云开发工程配置文件
          package.json    // 定义了TypeScript公共依赖

- sudoku-algorithm
   node_modules    // 自动为该函数引入依赖包
   function-config.json    // 函数的配置文件，可配置触发器，通过触发器暴露的触发条件来实现函数调用。
   package.json            // 包含了当前函数的名称、版本等函数元数据。
   sudoku-algorithm.ts    // 函数入口文件

{
    "type": "http",
    "properties": {
        "enableUrlDecode": true,
        "authFlag": "true",
        "authAlgor": "HDA-SYSTEM",
        "authType": "apigw-client"
    }
}

let myHandler = async function (event, context, callback, logger) {
  logger.info(event);

  // do something here
  callback({
    code: 0,
    desc: "Success.",
    data: "请求成功！"
  });
};
export { myHandler };

import agconnect from '@hw-agconnect/api-ohos';
import "@hw-agconnect/function-ohos";
import { Constants } from '../common/Constants';
import { Log } from '../common/Log';
import { getAGConnect } from './AgcConfig';

export function getSudokuPuzzle(context: any) {
  return new Promise((resolve, reject) => {
    getAGConnect(context);
    // 调用wrap方法设置函数，在方法中传入触发器标识，返回得到可执行云函数对象
    let functionCallable = agconnect.function().wrap("sudoku-algorithm-$latest");
    // 调用call方法运行云函数，若函数有入参，可以将参数转化为JSON对象或JSON字符串传入，若无参则不传
    functionCallable.call().then((ret: any) => {
      // 可调用getValue方法获取函数的返回值
      let result = ret.getValue();
      Log.info(Constants.LOG_TAG_NAME, `sudoku-algorithm called,  result: ${JSON.stringify(result)}`);
      resolve(result);
    }).catch((err: any) => {
      Log.error(Constants.LOG_TAG_NAME, `sudoku-algorithm failed, cause: ${JSON.stringify(err)}`);
    })
  });
}

Button('请求自定义云函数')
  .fontSize(16)
  .onClick(() => {
    getSudokuPuzzle(getContext(this)).then((ret) => {
      Log.info(Constants.LOG_TAG_NAME, `单击按钮调用云函数返回结果： ${JSON.stringify(ret)}`)
    })
  })

let myHandler = async function (event, context, callback, logger) {
  // 传递的关卡值作为需要填充的空格数
  let body = event.body;
  let params = JSON.parse(body);
  let levelNum = params.level;
  // 创建一个9*9的空白数独谜题
  let sudoku = Array.from({ length: 9 }, () => Array(9).fill(0));
  // 使用回溯算法填充数独谜题
  solve_sudoku(sudoku);
  // 随机移除一些数字，生成数独谜题
  remove_number(sudoku, levelNum);
  let solutions = answer_sudoku(sudoku);
  let sudokuPuzzle = {
    "original": sudoku,
    "answer": solutions
  }
  callback({
    code: 0,
    desc: "Success.",
    data: JSON.stringify(sudokuPuzzle)
  });
};

function solve_sudoku(sudoku){...}
function remove_number(sudoku, level){...}
function answer_sudoku(sudoku){...}

export { myHandler };

// 申请邮箱验证码
public requestEmailVerifyCode(email: string) {
    let verifyCodeSettings = new VerifyCodeSettingBuilder()
        .setAction(VerifyCodeAction.REGISTER_LOGIN)
        .setLang('zh_CN')
        .setSendInterval(60)
        .build();
    this.agc.auth().requestEmailVerifyCode(email, verifyCodeSettings)
        .then((ret) => {
            Log.info(TAG, JSON.stringify({ "Verify Code Result: ": ret }));
        }).catch((error) => {
        Log.error(TAG, "Error: " + JSON.stringify(error));
    });
}

// 邮箱账号注册登录
public async loginByEmail(email: string, verifyCode: string): Promise {
    return new Promise((resolve, reject) => {
        // 如果创建账户的时候没有设置过密码，则只能通过此接口进行登录
        let credential = EmailAuthProvider.credentialWithVerifyCode(email, verifyCode);
        // 登录接口，通过第三方认证来登录AGConnect平台
        this.agc.auth().signIn(credential).then(async (ret) => {
            Log.info(TAG, `User has signed in. User: ${JSON.stringify(ret)}`);
            let user = ret.getUser();
            let userExtra = await ret.getUser().getUserExtra();
            let loginRes = new AgUser(
                user.getUid(),
                user.getPhotoUrl(),
                user.getPhone(),
                user.getDisplayName(),
                userExtra.getCreateTime(),
                userExtra.getLastSignInTime())

            resolve(loginRes);
        }).catch((error) => {
            Log.error(TAG, "Error: ", error);
            reject(error);
        });
    });
}

Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) {
  Navigation() {
    Column() {
      Row({ space: Constants.LENGTH_5_PX }) {
        TextInput({ placeholder: '请输入邮箱账号..'})
          .type(InputType.Email)
          .layoutWeight(Constants.LENGTH_3_PX)
          .borderRadius(Constants.BORDER_RADIUS_4_PX)
          .maxLength(Constants.LENGTH_20_PX)
          .height(Constants.HEIGHT_40)
          .enabled(this.timer === 60)
          .onChange((val) => {
            this.email = val;
          })
      }
      .width(Constants.PERCENT_100)
      .justifyContent(FlexAlign.Center)
      .margin({ bottom: Constants.LENGTH_20_PX })

      Row({ space: Constants.LENGTH_5_PX }) {
        TextInput({ placeholder: '请输入验证码..', text: this.verificationCode })
          .layoutWeight(Constants.LENGTH_3_PX)
          .borderRadius(Constants.BORDER_RADIUS_4_PX)
          .maxLength(Constants.LENGTH_6_PX)
          .height(Constants.HEIGHT_40)
          .onChange((val) => {
            this.verificationCode = val;
          })

        Button(this.timer === 60 ? '获取验证码' : this.timer.toString(), {
          type: ButtonType.Normal
        })
          .backgroundColor('#f9fcfb')
          .layoutWeight(Constants.LENGTH_2_PX)
          .borderColor('#169cd5')
          .borderWidth(Constants.LENGTH_1_PX)
          .fontColor('#169cd5')
          .borderRadius(Constants.BORDER_RADIUS_4_PX)
          .height(Constants.HEIGHT_40)
          .enabled(this.validateEmailAddress(this.email) && this.timer === 60)
          .onClick(() => this.onGetCodeButtonClicked())
      }
      .width(Constants.PERCENT_100)
      .justifyContent(FlexAlign.Center)
      .margin({ bottom: Constants.LENGTH_20_PX })

      Button('登录', { type: ButtonType.Normal })
        .width(Constants.PERCENT_100)
        .borderRadius(Constants.BORDER_RADIUS_4_PX)
        .backgroundColor('#169cd5')
        .enabled(this.canAuthorize() && this.verificationCode.length > 5 && this.canLogin)
        .opacity(this.canLogin ? 1 : 0.5)
        .height(Constants.HEIGHT_40)
        .onClick(() => this.onAuthButtonClicked())
    }
    .width(Constants.PERCENT_90).height(Constants.HEIGHT_50)
    .justifyContent(FlexAlign.Center)
    .margin({ top: Constants.LENGTH_40_PX })
    .padding({
      right: Constants.LENGTH_15_PX,
      left: Constants.LENGTH_15_PX
    })
    .borderRadius(Constants.LENGTH_8_PX)
    .backgroundColor(0xFFFFFF)
  }
  .title(this.NavigationTitle())
  .titleMode(NavigationTitleMode.Full)
  .hideTitleBar(false)
  .hideToolBar(false)
}
.width(Constants.PERCENT_100).height(Constants.PERCENT_100)
.backgroundColor(Constants.VIEW_BG_COLOR)

onAuthButtonClicked = () => {
  this.canLogin = false;
  this.agcAuth.loginByEmail(this.email, this.verificationCode).then((user) => {
    PreferencesUtil.putPreference(getContext(this), Constants.USER_AUTH_INFO, JSON.stringify(user));
    Log.info(Constants.LOG_TAG_NAME, `Logged in successfully. Data: ${JSON.stringify(user)}`);
    this.canLogin = true;
  }).catch((err) => {
    this.canLogin = true;
    Log.error(Constants.LOG_TAG_NAME, `Logged in failed. Cause: ${JSON.stringify(err)}`);
  })
}

// 获取数独谜题和解
getSudoPuzzle = () => {
  let _this = this;
  getSudokuPuzzle(getContext(this), this.levelNum).then((ret: string) => {
    let result: SudokuPuzzle = JSON.parse(ret);
    _this.puzzles = result.original;
    _this.answers = result.answer;
  }).catch((err) => {
    Log.error(Constants.LOG_TAG_NAME, `cause: ${JSON.stringify(err)}`);
  })
}

Grid() {
  ForEach(this.puzzles, (item: Array, i: number) => {
    ForEach(item, (temp: number, j: number) => {
      GridItem() {
        if (temp === 0) {
          TextInput()
            .type(InputType.Number)
            .maxLength(1)
            .backgroundColor(0xf47721)
            .caretColor(Color.White)
            .onChange((val) => {
              let answer = this.puzzles;
              answer[i][j] = parseInt(val);
              this.userAnswer = answer;
              Log.info(Constants.LOG_TAG_NAME, JSON.stringify(this.userAnswer));
              if (val == "") {
                this.userAnswer = [];
              }
            })
        } else {
          Text(temp.toString())
            .fontSize(16)
        }
      }
      .borderWidth(1)
    }, (temp: number) => temp.toString())
  }, (item: Array) => item.toString())
}
.columnsTemplate('1fr 1fr 1fr 1fr 1fr 1fr 1fr 1fr 1fr')
.rowsTemplate('1fr 1fr 1fr 1fr 1fr 1fr 1fr 1fr 1fr')
.width(Constants.PERCENT_96)
.height(400)
.backgroundColor(0xFFFFFF)

Column() {
  Image($r("app.media.card_start"))
    .width(this.FULL_WIDTH_PERCENT)
    .height(this.FULL_HEIGHT_PERCENT)
    .objectFit(ImageFit.Cover)
}
.width(this.FULL_WIDTH_PERCENT)
.height(this.FULL_HEIGHT_PERCENT)
.onClick(() => {
  postCardAction(this, {
    "action": this.ACTION_TYPE,
    "abilityName": this.ABILITY_NAME,
    "params": {
      "message": this.MESSAGE
    }
  });
})

{
  "name": "game",
  "description": "数独闯关游戏",
  "src": "./ets/widget/pages/GameCard.ets",
  "uiSyntax": "arkts",
  "window": {
    "designWidth": 720,
    "autoDesignWidth": true
  },
  "colorMode": "auto",
  "isDefault": false,
  "updateEnabled": false,
  "scheduledUpdateTime": "10:30",
  "updateDuration": 1,
  "defaultDimension": "4*4",
  "supportDimensions": [
    "4*4"
  ]
}

{
  "module": {
    ...
    "extensionAbilities": [
      {
        "name": "EntryFormAbility",
        "srcEntrance": "./ets/entryformability/EntryFormAbility.ts",
        "label": "$string:EntryFormAbility_label",
        "description": "$string:EntryFormAbility_desc",
        "type": "form",
        "metadata": [
          {
            "name": "ohos.extension.form",
            "resource": "$profile:form_config"
          }
        ]
      }
    ]
  }
}

Image($r('app.media.game_start'))
  .width(120).height(54)
  .onClick(() => {
    postCardAction(this, {
      'action': 'message',
      'params': {
        'functionName': 'getSudoPuzzle'
      }
    })
  })

onFormEvent(formId, message) {
  let params = JSON.parse(message);
  Log.info(Constants.LOG_TAG_NAME, `message ===> ${params.functionName}`);
  // Called when a specified message event defined by the form provider is triggered.
  if (params.functionName === "getSudoPuzzle") {
    let promise = PreferenceUtil.getPreference(this.context, Constants.GAME_LEVEL);
    promise.then((ret) => {
      let level = parseInt(ret);
      let puzzles = [], answers = [];
      getSudokuPuzzle(this.context, level).then((ret: string) => {
        let result: SudokuPuzzle = JSON.parse(ret);
        puzzles = result.original;
        answers = result.answer;
        let formData = {
          flag: true,
          puzzles: puzzles,
          answers: answers,
          level: level
        }
        let formBD = formBindingData.createFormBindingData(formData);
        Log.info(Constants.LOG_TAG_NAME, `level. ${JSON.stringify(formBD)}`);
        formProvider.updateForm(formId, formBD).then((data) => {
          Log.info(Constants.LOG_TAG_NAME, `FormAbility updateForm success. ${JSON.stringify(data)}`);
        }).catch((err) => {
          Log.error(Constants.LOG_TAG_NAME, `FormAbility updateForm failed. ${JSON.stringify(err)}`);
        })
      }).catch((err) => {
        Log.error(Constants.LOG_TAG_NAME, `cause: ${JSON.stringify(err)}`);
      })
    })
  }
}

@LocalStorageProp("puzzles") puzzles: Array> = [];
@LocalStorageProp("answers") answers: Array>> = [];

Row() {}
.backgroundColor(0xD1D3D5)
.width(this.FULL_HEIGHT_PERCENT)
.height(this.FULL_HEIGHT_PERCENT)
.onClick(() => {
  this.selectArr = [i, j];
})

ForEach([1, 2, 3, 4, 5, 6, 7, 8, 9], (item: number) => {
  Button({ type: ButtonType.Normal }) {
    Text(item.toString()).fontSize(14).fontWeight(700)
  }
  .backgroundColor(Color.Orange)
  .borderRadius(4)
  .width(30).height(30)
  .fontSize(12)
  .onClick(() => {
    if (this.selectArr.length !== 0) {
      let row = this.selectArr[0];
      let col = this.selectArr[1];
      this.puzzles[row][col] = item;
      postCardAction(this, {
        'action': 'message',
        'params': {
          'functionName': 'refresh',
          'puzzles': this.puzzles
        }
      })
      this.userAnswer = this.puzzles;
      this.selectArr = [];
    }
  })
})

if (params.functionName === 'refresh') {
  let formData = {
    puzzles: params.puzzles
  }
  let formBD = formBindingData.createFormBindingData(formData);
  formProvider.updateForm(formId, formBD);
}

{
  "name": "history",
  "description": "历史闯关记录",
  "src": "./ets/widget/pages/HistoryCard.ets",
  "uiSyntax": "arkts",
  "window": {
    "designWidth": 720,
    "autoDesignWidth": true
  },
  "colorMode": "auto",
  "isDefault": false,
  "updateEnabled": false,
  "scheduledUpdateTime": "02:35",
  "updateDuration": 1,
  "defaultDimension": "2*4",
  "supportDimensions": [
    "2*4"
  ]
}

let formStorage = PreferenceUtil.getPreference(this.context, Constants.FORM_CARD_Dimension_2_4);
formStorage.then((ret) =>{
  let formArr: Array = new Array();
  if (ret !== "") {
    formArr = JSON.parse(ret);
    formArr.push(formInfoStorage);
  } else {
    formArr.push(formInfoStorage);
  }
  PreferenceUtil.putPreference(this.context, Constants.FORM_CARD_Dimension_2_4, JSON.stringify(formArr));
})
let promise = PreferenceUtil.getPreference(this.context, Constants.HISTORY_RECORDS);
promise.then((ret) => {
  if (ret !== "") {
    let historyArr: Array = JSON.parse(ret);
    formData = {
      histories: historyArr
    }
    let formBD = formBindingData.createFormBindingData(formData);
    formProvider.updateForm(formId, formBD);
    return formBD;
  }
})

PreferenceUtil.getPreference(this.context, Constants.HISTORY_RECORDS).then((ret) => {
  let historyArr: Array =  [];
  if (ret !== "") {
    historyArr = JSON.parse(ret);
    historyArr.push(history);
  } else {
    historyArr.push(history);
  }
  PreferenceUtil.putPreference(this.context, Constants.HISTORY_RECORDS, JSON.stringify(historyArr));
  let formStorage = PreferenceUtil.getPreference(this.context, Constants.FORM_CARD_Dimension_2_4);
  formStorage.then((ret) =>{
    if (ret !== "") {
      let formArr: Array = JSON.parse(ret);
      formArr.forEach((item) => {
        let promise = PreferenceUtil.getPreference(this.context, Constants.HISTORY_RECORDS);
        promise.then((ret) => {
          if (ret !== "") {
            let historyArr: Array = JSON.parse(ret);
            let formData = {
              histories: historyArr
            }
            let formBD = formBindingData.createFormBindingData(formData);
            formProvider.updateForm(item.formId, formBD);
          }
        })
      })
    }
  })
})