Database user check (#125)

* spalsh user check

* spalsh user check format

* navigation according to dat

* navigation according to dat format

* changes for names convention

* changes for names convention format

* changes for names to camelcase

* changes for names to camelcase format

packages/data/src/out/database_port.ts

@@ -1,6 +1,7 @@
 import { UserModel } from 'shared'
 
 export interface DatabasePort {
-  adduser(params?: { email: string; password: string; token: string }): Promise<boolean>
-  getUserDetails(data: UserModel): Promise<UserModel>
+  addUser(params?: { email: string; password: string; token: string }): Promise<boolean>
+  fetchUserData(data: UserModel): Promise<UserModel>
+  fetchUserExists(data: UserModel): Promise<boolean>
 }

packages/data/src/out/network_port.ts

@@ -1,5 +1,5 @@
 import { UserModel } from 'shared'
 
 export interface NetworkPort {
-  loginCall(params?: { email: string; password: string }): Promise<UserModel>
+  login(params?: { email: string; password: string }): Promise<UserModel>
 }

packages/data/src/repositories/user_repository_impl.ts

@@ -12,22 +12,27 @@ export class UserRepositoryImpl implements UserRepository {
     this.network = params.networkPort
   }
 
-  async loginCheck(params?: { email: string; password: string }): Promise<boolean> {
-    const usermodel: any = await this.network.loginCall({ email: params.email, password: params.password })
+  async login(params?: { email: string; password: string }): Promise<boolean> {
+    const usermodel: any = await this.network.login({ email: params.email, password: params.password })
+    console.log(usermodel)
     if (usermodel == 'Request failed with status code 403') {
       return usermodel
     } else {
-      console.log(usermodel.access_token)
-      const databaseResponse = await this.database.adduser({
+      const databaseResponse = await this.database.addUser({
         email: params.email,
         password: params.password,
         token: usermodel.access_token
       })
       return databaseResponse
     }
   }
-  async getuserdata(params?: { email: string }): Promise<UserModel> {
-    return await this.database.getUserDetails({
+  async fetchUserData(params?: { email: string }): Promise<UserModel> {
+    return await this.database.fetchUserData({
+      email: params.email
+    })
+  }
+  async fetchUserExists(params?: { email: string }): Promise<boolean> {
+    return await this.database.fetchUserExists({
       email: params.email
     })
   }

packages/database-watermelon/src/dao/user_dao.ts

@@ -30,8 +30,13 @@ export class UserDao extends BaseDao<DbUserModel> {
     )
   }
 
-  async getUser(data: { email: string }): Promise<DbUserModel> {
+  async fetchUserData(data: { email: string }): Promise<DbUserModel> {
     const response: any = await safeDbCall(this.databaseData.query().fetch())
-    return !response ? [] : response[0]?._raw?.email
+    return response[0] ? response[0]?._raw?.email : []
+  }
+  async fetchUserExists(data: { email: string }): Promise<boolean> {
+    const userCount: number = await safeDbCall(this.databaseData.query().fetchCount())
+    if (userCount > 0) return true
+    else return false
   }
 }

packages/database-watermelon/src/database_adapter.ts

@@ -9,7 +9,7 @@ class DatabaseAdapter implements DatabasePort {
     this.databases = params.databases
   }
 
-  async adduser(params?: { email: string; password: string; token: string }): Promise<boolean> {
+  async addUser(params?: { email: string; password: string; token: string }): Promise<boolean> {
     const response = await this.databases.userDao.insertOrUpdate({
       email: params.email,
       password: params.password,
@@ -18,8 +18,13 @@ class DatabaseAdapter implements DatabasePort {
     if (response) return true
   }
 
-  async getUserDetails(data: UserModel): Promise<UserModel> {
-    return await this.databases.userDao.getUser({
+  async fetchUserData(data: UserModel): Promise<UserModel> {
+    return await this.databases.userDao.fetchUserData({
+      email: data.email
+    })
+  }
+  async fetchUserExists(data: UserModel): Promise<boolean> {
+    return await this.databases.userDao.fetchUserExists({
       email: data.email
     })
   }

packages/domain/src/di/domain_module.ts

@@ -1,17 +1,22 @@
-import { LoginCheckUsecase, UserDetailsUseCase } from 'domain-layer'
 import { UserRepository } from './../repository/user_repository'
 import { DataModule } from 'data'
 import { Graph, ObjectGraph, Provides, Singleton } from 'di'
+import { LoginUseCase } from '../usecases/login_user_usecase'
+import { FetchUserDataUseCase, FetchUserExistsUseCase } from '../domain'
 
 @Singleton()
 @Graph({ subgraphs: [DataModule] })
 export class DomainModule extends ObjectGraph {
   @Provides()
-  providesLoginCheckUseCase(provideUserRepository: UserRepository): LoginCheckUsecase {
-    return new LoginCheckUsecase(provideUserRepository)
+  providesLoginUseCase(provideUserRepository: UserRepository): LoginUseCase {
+    return new LoginUseCase(provideUserRepository)
   }
   @Provides()
-  provideUserDetailsUseCase(provideUserRepository: UserRepository): UserDetailsUseCase {
-    return new UserDetailsUseCase(provideUserRepository)
+  provideUserDataUseCase(provideUserRepository: UserRepository): FetchUserDataUseCase {
+    return new FetchUserDataUseCase(provideUserRepository)
+  }
+  @Provides()
+  provideUserExistsUseCase(provideUserRepository: UserRepository): FetchUserExistsUseCase {
+    return new FetchUserExistsUseCase(provideUserRepository)
   }
 }

packages/domain/src/domain.ts

@@ -1,13 +1,16 @@
-import { LoginCheckParams, LoginCheckUsecase } from './usecases/login_check_usecase'
+import { FetchUserExistsUseCase, FetchUserExistsUseCaseParams } from './usecases/user_present_data_usecase'
+import { FetchUserDataUseCase, FetchUserDataUseCaseParams } from './usecases/user_details_usecase'
+import { LoginUseCase, LoginParams } from './usecases/login_user_usecase'
 import { DomainModule } from './di/domain_module'
 import { UserRepository } from './repository/user_repository'
-import { UserDetailsUseCaseParams, UserDetailsUseCase } from './usecases/user_details_usecase'
 
 export {
-  LoginCheckParams,
-  LoginCheckUsecase,
   DomainModule,
   UserRepository,
-  UserDetailsUseCase,
-  UserDetailsUseCaseParams
+  LoginUseCase,
+  LoginParams,
+  FetchUserDataUseCase,
+  FetchUserDataUseCaseParams,
+  FetchUserExistsUseCase,
+  FetchUserExistsUseCaseParams
 }

packages/domain/src/repository/user_repository.ts

@@ -1,6 +1,7 @@
 import { UserModel } from 'shared'
 
 export interface UserRepository {
-  loginCheck(params?: { email: string; password: string }): Promise<boolean>
-  getuserdata(params?: { email: string }): Promise<UserModel>
+  login(params?: { email: string; password: string }): Promise<boolean>
+  fetchUserData(params?: { email: string }): Promise<UserModel>
+  fetchUserExists(params?: { email: string }): Promise<boolean>
 }

packages/domain/src/usecases/login_check_usecase.ts → packages/domain/src/usecases/login_user_usecase.ts

@@ -2,23 +2,22 @@ import { UserRepository } from '../repository/user_repository'
 import { FutureUseCase } from './base/base_usecase'
 import { Params } from './base/params'
 
-export class LoginCheckUsecase extends FutureUseCase<LoginCheckParams, boolean> {
+export class LoginUseCase extends FutureUseCase<LoginParams, boolean> {
   private readonly userRepository: UserRepository
   constructor(repo: UserRepository) {
     super()
     this.userRepository = repo
   }
-  async execute(params?: LoginCheckParams): Promise<boolean> {
+  async execute(params?: LoginParams): Promise<boolean> {
     if (params?.verify()) {
-      console.log('in verify ')
-      return await this.userRepository.loginCheck({
+      return await this.userRepository.login({
         email: params.email,
         password: params.password
       })
     } else return false
   }
 }
-export class LoginCheckParams extends Params {
+export class LoginParams extends Params {
   readonly email?: string
   readonly password?: string
 

packages/domain/src/usecases/user_details_usecase.ts

@@ -3,21 +3,21 @@ import { UserRepository } from '../domain'
 import { FutureUseCase } from './base/base_usecase'
 import { Params } from './base/params'
 
-export class UserDetailsUseCase extends FutureUseCase<UserDetailsUseCaseParams, UserModel> {
+export class FetchUserDataUseCase extends FutureUseCase<FetchUserDataUseCaseParams, UserModel> {
   private readonly userRepository: UserRepository
   constructor(repo: UserRepository) {
     super()
     this.userRepository = repo
   }
-  async execute(params?: UserDetailsUseCaseParams): Promise<UserModel> {
+  async execute(params?: FetchUserDataUseCaseParams): Promise<UserModel> {
     if (params?.verify) {
-      return await this.userRepository.getuserdata({
+      return await this.userRepository.fetchUserData({
         email: params.email
       })
     }
   }
 }
-export class UserDetailsUseCaseParams extends Params {
+export class FetchUserDataUseCaseParams extends Params {
   readonly email?: string
 
   constructor(params?: { email: string }) {

packages/domain/src/usecases/user_present_data_usecase.ts

@@ -0,0 +1,31 @@
+import { UserModel } from 'packages/shared/src/shared'
+import { UserRepository } from '../domain'
+import { FutureUseCase } from './base/base_usecase'
+import { Params } from './base/params'
+
+export class FetchUserExistsUseCase extends FutureUseCase<FetchUserExistsUseCaseParams, boolean> {
+  private readonly userRepository: UserRepository
+  constructor(repo: UserRepository) {
+    super()
+    this.userRepository = repo
+  }
+  async execute(params?: FetchUserExistsUseCaseParams): Promise<boolean> {
+    if (params?.verify) {
+      return await this.userRepository.fetchUserExists({
+        email: params.email
+      })
+    }
+  }
+}
+export class FetchUserExistsUseCaseParams extends Params {
+  readonly email?: string
+
+  constructor(params?: { email: string }) {
+    super({})
+    this.email = params.email
+  }
+
+  verify(): boolean {
+    return true
+  }
+}

packages/mobile/src/feature/dashboard/dashboard_screen.tsx

@@ -6,30 +6,26 @@ import { AppButton } from '../../widgets/app_button/app_button'
 import { useTheme } from '../../theme/themeprovider'
 import { useEffect, useState } from 'react'
 import { useDispatch, useSelector } from 'react-redux'
-import { userDataRequest } from 'presentation'
+import { fetchUserAction } from 'presentation'
 
 const DashboardScreen = () => {
   const { theme, isDark } = useTheme()
   const [lodingState, setLodingState] = useState(false)
-  const databaseemail: any = useSelector((state: any) => state?.userData?.data?.payload)
+  const databaseEmail: any = useSelector((state: any) => state?.userData?.data?.payload)
   const dispatch = useDispatch()
   useEffect(() => {
-    dispatch(userDataRequest({}))
+    dispatch(fetchUserAction({}))
   }, [])
-  const saveData = () => {
-    setLodingState(true)
-    dispatch(userDataRequest({}))
-  }
   return (
     <View style={style.mainView}>
       <View style={[style.secView, { backgroundColor: theme.secondaryColor }]}>
-        <Text style={[style.uberText, { color: theme.textColor }]}>{i18n.t('uber')}</Text>
+        <Text style={[style.uberText, { color: theme.textColor }]}>{`${i18n.t('uber')} -  ${databaseEmail}`}</Text>
         <Text style={[style.getText, { color: theme.textColor }]}>{i18n.t('getThere')}</Text>
 
         <Image source={isDark ? Images.carBlack : Images.car} style={style.carStyle} resizeMode="contain" />
       </View>
       <View style={style.thirdView}>
-        <AppButton value={'getStarted'} saveData={() => saveData()} />
+        <AppButton value={'getStarted'} />
       </View>
     </View>
   )

packages/mobile/src/feature/login/login_screen.tsx

@@ -7,7 +7,7 @@ import i18n from 'localisation'
 import { useDispatch, useSelector } from 'react-redux'
 import { AppButton } from '../../widgets/app_button/app_button'
 import { AppInput } from '../../widgets/app_input/app_input'
-import { userRequest } from 'presentation'
+import { loginAction } from 'presentation'
 import { useTheme } from '../../theme/themeprovider'
 import { useNavigation } from '@react-navigation/native'
 import RoutePaths from '../../navigation/router_path'
@@ -20,22 +20,22 @@ const LoginScreen = () => {
   const [password, setPassword] = useState<string>('')
   const [loadingState, setLodingState] = useState<boolean>(false)
   const dispatch = useDispatch()
-  const loginData: any = useSelector<any>(state => state.loginData)
+  const loginData: any = useSelector<any>(state => state?.login)
   const saveData = () => {
     const data = {
       email: username,
       password: password
     }
-    dispatch(userRequest({ data: data }))
+    dispatch(loginAction({ data: data }))
   }
   useEffect(() => {
-    if (loginData?.status == Status.loading) setLodingState(true)
+    if (loginData?.status == Status?.loading) setLodingState(true)
     else setLodingState(false)
   }, [loginData])
 
   useEffect(() => {
-    if (loginData?.status == Status.success) navigation.navigate(RoutePaths.dashboard)
-    else if (loginData?.status == Status.error) alert(i18n.t('noInput'))
+    if (loginData?.status == Status?.success) navigation.navigate(RoutePaths.dashboard)
+    else if (loginData?.status == Status?.error) alert(i18n.t('noInput'))
   }, [loginData])
 
   return (

packages/mobile/src/navigation/app_router.tsx

@@ -1,20 +1,27 @@
 import { NavigationContainer } from '@react-navigation/native'
 import { createNativeStackNavigator } from '@react-navigation/native-stack'
-import React from 'react'
+import React, { useEffect } from 'react'
 import DashboardScreen from '../feature/dashboard/dashboard_screen'
 import LoginScreen from '../feature/login/login_screen'
 import RoutePaths from './router_path'
+import { useDispatch, useSelector } from 'react-redux'
+import { fetchUserExistsAction } from 'presentation'
 
 const AppRouter = () => {
   const Stack = createNativeStackNavigator()
+  const databaseEmail: any = useSelector((state: any) => state?.userPresentData?.data?.payload)
+  const dispatch = useDispatch()
+  useEffect(() => {
+    dispatch(fetchUserExistsAction({}))
+  }, [])
   return (
     <NavigationContainer>
       <Stack.Navigator
         screenOptions={{
           headerShown: false
         }}
       >
-        <Stack.Screen name={RoutePaths.login} component={LoginScreen} />
+        {!databaseEmail && <Stack.Screen name={RoutePaths.login} component={LoginScreen} />}
         <Stack.Screen name={RoutePaths.dashboard} component={DashboardScreen} />
       </Stack.Navigator>
     </NavigationContainer>

packages/network-retrofit/src/network_adapter.ts

@@ -9,7 +9,7 @@ class NetworkAdapter implements NetworkPort {
     this.retrofitService = params.retrofitService
   }
 
-  async loginCall(params?: { email: string; password: string }): Promise<UserModel> {
+  async login(params?: { email: string; password: string }): Promise<UserModel> {
     const response = await safeApiCall(this.retrofitService.login({ email: params.email, password: params.password }))
     return response.data
   }

packages/presentation/src/feature/login/actions.ts

@@ -1,10 +1,10 @@
-export enum REQUEST_USER {
-  MAKE_REQUEST = 'MAKE_REQUEST',
-  REQUEST_USER_SUCCESS = 'REQUEST_USER_SUCCESS',
-  REQUEST_USER_FAILURE = 'REQUEST_USER_FAILURE'
+export enum LOGIN {
+  request = 'LOGIN_REQUEST',
+  success = 'LOGIN_SUCCESS',
+  failure = 'LOGIN_FAILURE'
 }
 
-export const userRequest = params => ({
-  type: REQUEST_USER.MAKE_REQUEST,
+export const loginAction = params => ({
+  type: LOGIN.request,
   params
 })

packages/presentation/src/feature/login/reducer.ts

@@ -1,23 +1,23 @@
 import data from 'packages/data/lib/data'
 import { Resource } from '../../utils/resource'
-import { REQUEST_USER } from './actions'
+import { LOGIN } from './actions'
 
-const userRequestReducer = (initialState = Resource.none, action) => {
+const loginReducer = (initialState = Resource.none, action) => {
   switch (action.type) {
-    case REQUEST_USER.MAKE_REQUEST:
+    case LOGIN.request:
       return Resource.loading()
 
-    case REQUEST_USER.REQUEST_USER_SUCCESS:
+    case LOGIN.success:
       return Resource.success({
         data: action
       })
 
-    case REQUEST_USER.REQUEST_USER_FAILURE:
+    case LOGIN.failure:
       return Resource.error({
         error: 'User Not logged in'
       })
     default:
       return initialState
   }
 }
-export default userRequestReducer
+export default loginReducer