jw-beauty/miniprogram/pages/scan-report/scan-report.js

var api = require('../../utils/api')
var ble = require('../../services/ble')
var diagnosis = require('../../services/diagnosis')
var i18n = require('../../i18n/index')

var WAVE_CODE_KEY = { 1: 'infrared', 2: 'red', 3: 'uv', 4: 'yellow' }

function pad2(n) { return (n < 10 ? '0' : '') + n }

function formatTime(ms) {
  if (!ms) ms = Date.now()
  var d = new Date(ms)
  return d.getFullYear() + '-' + pad2(d.getMonth() + 1) + '-' + pad2(d.getDate()) +
    ' ' + pad2(d.getHours()) + ':' + pad2(d.getMinutes())
}

Page({
  data: {
    statusBarHeight: 44,
    loading: true,
    calibrated: true,
    hasProblem: false,
    scannedAtText: '',
    overallList: [],
    regionList: [],
    recommendList: [],
    starting: false,
    error: ''
  },

  onLoad: function (options) {
    var app = getApp()
    this.setData({ statusBarHeight: app.globalData.statusBarHeight })
    this._options = options || {}
  },

  onShow: function () {
    i18n.bind(this)
    this._loadReport()
  },

  onBack: function () {
    wx.navigateBack({ fail: function () { wx.reLaunch({ url: '/pages/index/index' }) } })
  },

  _loadReport: function () {
    var self = this
    var app = getApp()
    var opts = self._options || {}

    if (opts.report_id) {
      self.setData({ loading: true })
      api.getReport(opts.report_id).then(function (rep) {
        self._render(self._normalize(rep))
      }).catch(function () { self._fallback() })
      return
    }
    if (app.globalData.lastScanReport) {
      self._render(app.globalData.lastScanReport)
      return
    }
    self.setData({ loading: true })
    api.getLatestReport().then(function (rep) {
      // Backend ok() coerces null -> {}, so treat an empty payload as "no report".
      if (self._hasContent(rep)) self._render(self._normalize(rep))
      else self._fallback()
    }).catch(function () { self._fallback() })
  },

  _hasContent: function (rep) {
    if (!rep) return false
    return !!((rep.regions && rep.regions.length) ||
      (rep.overall && rep.overall.length) ||
      (rep.recommend_plan && rep.recommend_plan.length))
  },

  _fallback: function () {
    // Preview/demo when no device data is available yet.
    this._render(diagnosis.mockReport())
  },

  _normalize: function (rep) {
    if (!rep) return diagnosis.mockReport()
    var scannedAt = 0
    if (typeof rep.scanned_at === 'number') scannedAt = rep.scanned_at
    else if (rep.scanned_at) scannedAt = Date.parse(rep.scanned_at) || 0
    return {
      device_id: rep.device_id || null,
      scanned_at: scannedAt,
      regions: rep.regions || [],
      overall: rep.overall || [],
      recommend_mask: rep.recommend_mask || 0,
      recommend_plan: rep.recommend_plan || [],
      raw_pd: rep.raw_pd || {},
      calibrated: !!rep.calibrated
    }
  },

  _render: function (report) {
    var d = i18n.getDict().report
    var common = i18n.getDict().common

    function levelLabel(l) {
      if (l >= 3) return d.level.high
      if (l === 2) return d.level.mid
      if (l === 1) return d.level.low
      return d.noProblem
    }

    var overallList = (report.overall || []).map(function (o) {
      return { label: d.problems[o.type] || o.type, level: o.level, levelLabel: levelLabel(o.level) }
    })

    var regionList = (report.regions || []).map(function (r) {
      return {
        name: d.regionNames[r.region] || r.region,
        level: r.level,
        levelLabel: levelLabel(r.level),
        problemLabel: r.top_problem ? (d.problems[r.top_problem] || r.top_problem) : d.noProblem,
        hasProblem: !!r.top_problem
      }
    })

    var defs = diagnosis.REGION_DEFS
    var recommendList = (report.recommend_plan || []).map(function (p) {
      var names = []
      for (var i = 0; i < defs.length; i++) {
        if (p.mask & defs[i].mask) names.push(d.regionNames[defs[i].key] || defs[i].key)
      }
      var waveKey = WAVE_CODE_KEY[p.wavelength]
      return {
        label: d.problems[p.label_key] || '',
        wavelengthLabel: (waveKey && common.wavelengths[waveKey]) || '',
        regionsLabel: names.join('、'),
        wavelength: p.wavelength,
        mask: p.mask
      }
    })

    this._report = report
    this.setData({
      loading: false,
      calibrated: !!report.calibrated,
      hasProblem: overallList.length > 0,
      scannedAtText: formatTime(report.scanned_at),
      overallList: overallList,
      regionList: regionList,
      recommendList: recommendList,
      error: ''
    })
  },

  onStartRecommend: function () {
    var self = this
    var report = self._report || {}
    if (!ble.isConnected()) {
      self.setData({ error: i18n.t('common.deviceNotConnected') })
      return
    }
    var plan = (report.recommend_plan && report.recommend_plan[0]) || null
    var mask = plan ? plan.mask : (report.recommend_mask || 0x1F)
    var wl = plan ? plan.wavelength : 2
    if (!mask) mask = 0x1F

    self.setData({ starting: true, error: '' })
    ble.setParams({
      region_mask: mask, wavelength: wl, brightness: 140,
      duration_ms: 600000, mode: 1, control: 0x02
    }).then(function () {
      return ble.startTreatment(mask)
    }).then(function () {
      wx.redirectTo({
        url: '/pages/treating/treating?regions=' + mask +
          '&wavelength=' + wl + '&duration=600000&mode=1'
      })
    }).catch(function (err) {
      self.setData({ starting: false, error: (err && err.error_msg) || i18n.t('common.networkError') })
    })
  },

  onManual: function () {
    wx.redirectTo({ url: '/pages/manual-treatment/manual-treatment' })
  }
})