App.js

/*
    uMetric.app
    Copyright (C) 2021  Daniel Moreno Medina

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
import 'react-native-gesture-handler'
import React, { useEffect } from 'react'
import { LogBox, Linking } from 'react-native'
import * as Localization from 'expo-localization'
import i18n from 'i18n-js'
import urlParse from 'url-parse'
import Toast from 'react-native-toast-message'
import 'react-native-get-random-values'
import { v4 as uuidv4 } from 'uuid'

import CompleteFlow from './navigation/CompleteFlow'
import * as RootNavigation from './navigation/RootNavigation'
import { en, es, pt, jp, zh, ru, ph, de } from './i18n/supportedLanguages'
import { getCurrentUser, createAndSetCurrentUser } from './utils/userUtils'
import { startAutomaticSync, stopAutomaticSync } from './utils/syncService'

import { Database } from '@nozbe/watermelondb'
import SQLiteAdapter from '@nozbe/watermelondb/adapters/sqlite'
import { DatabaseProvider } from '@nozbe/watermelondb/DatabaseProvider'
import { umetricSchema } from './model/schema'
import Category from './model/Category'
import Event from './model/Event'
import EventLog from './model/EventLog'
import Goal from './model/Goal'
import LikertScale from './model/LikertScale'
import LikertScaleTranslation from './model/LikertScaleTranslation'
import Question from './model/Question'
import QuestionLikert from './model/QuestionLikert'
import QuestionTranslation from './model/QuestionTranslation'
import Questionnaire from './model/Questionnaire'
import QuestionnaireResponse from './model/QuestionnaireResponse'
import QuestionnaireTranslation from './model/QuestionnaireTranslation'
import Response from './model/Response'
import User from './model/User'
import { setGenerator } from '@nozbe/watermelondb/utils/common/randomId'
import { schemaMigrations, addColumns } from '@nozbe/watermelondb/Schema/migrations'

i18n.fallbacks = true
i18n.translations = { en, es, pt, jp, zh, ru, ph, de }
i18n.locale = Localization.getLocales()[0].languageCode

LogBox.ignoreLogs(['Setting a timer'])

setGenerator(() => uuidv4())
const migrations = schemaMigrations({
  migrations: [
    {
      toVersion: 2,
      steps: [
        addColumns({
          table: 'users',
          columns: [
            { name: 'server_url', type: 'string', isOptional: true },
            { name: 'encryption_key', type: 'string', isOptional: true },
            { name: 'sync_frequency', type: 'string', isOptional: true },
          ],
        }),
      ],
    },
  ],
})
const adapter = new SQLiteAdapter({ schema: umetricSchema, migrations })
const database = new Database({
  adapter,
  modelClasses: [
    Category,
    Event,
    EventLog,
    Goal,
    LikertScale,
    LikertScaleTranslation,
    Question,
    QuestionLikert,
    QuestionTranslation,
    Questionnaire,
    QuestionnaireResponse,
    QuestionnaireTranslation,
    Response,
    User,
  ],
  actionsEnabled: true,
})

const App = () => {
  useEffect(() => {
    const handleUrl = async (url) => {
      console.log('Deep link received:', url)
      try {
        const parsedUrl = urlParse(url, true)
        let category_id = null
        
        // umetric://category/UUID
        if (parsedUrl.pathname) {
          const parts = parsedUrl.pathname.split('/').filter(part => part.length > 0)

          if (parts.length >= 1) {
            category_id = parts[0]
          }
        }
        
        if (category_id) {          
          try {
            const category = await database.collections
              .get('categories')
              .find(category_id.toString())

            RootNavigation.navigate('Input', {
              screen: 'ListEvents',
              params: {
                category_id: category_id,
                category_name: category.name,
                fromDeepLink: true
              }
            })
          } catch (error) {
            RootNavigation.navigate('Input', { screen: 'ListCategories' })
          }
        } else {
          console.log('No valid category_id found in URL')
        }
      } catch (error) {
        console.error('Error handling deep link:', error)
      }
    }

    const subscription = Linking.addEventListener('url', ({ url }) => {
      console.log('URL event received:', url)
      handleUrl(url)
    })

    Linking.getInitialURL().then((url) => {
      console.log('Initial URL:', url)
      if (url) {
        handleUrl(url)
      }
    })

    return () => {
      subscription?.remove()
    }
  }, [])

  // Ensure a user exists at app start and initialize sync
  useEffect(() => {
    const ensureUser = async () => {
      const user = await getCurrentUser(database)
      if (!user) {
        await createAndSetCurrentUser(database)
      } else {
        // Start automatic sync if enabled
        try {
          await startAutomaticSync(database)
        } catch (error) {
          console.error('Failed to start automatic sync:', error)
        }
      }
    }
    ensureUser()

    // Cleanup on unmount
    return () => {
      stopAutomaticSync()
    }
  }, [])

  return (
    <DatabaseProvider database={database}>
      <CompleteFlow />
      <Toast />
    </DatabaseProvider>
  )
}

export default App