PROJECT REPORT

Mone
y
Matte
rs: A
Perso
nal
Finan
ce
Mana
geme
nt
App
 1. INTRODUCTION

1.1 Overview
The Money Matters allows users to track the personal budgets on a daily,

weekly or monthly basis. The app should have user - friendly interfaces, easy-to-use

features, and personalized alerts based on spending patterns.

1.2Purpose

The app allows user to keep track of their expenses and accounts, and

provides an overview of their financial status. Users can set a budget for various

expenses and view their progress towards it.

 2 PROBLEM DEFINITION & DESIGN THINKING

2.1Empathy Map

2.2Ideation & Brainstorming Map

 3 RESULT

Login Page
Register Page
Main Page
Add Expenses Page
Set Limit Page before adding any data in expenses
View Records Page
Set Limit Page After adding expenes in add expense page
 4 ADVANTAGES & DISADVANTAGES

4.1Advantages

1) Have a significant financial control

2) Be prepared for unforeseen circumstances

3) Track the expenses

4) Set the limit for expenses

4.2Disadvantages

1) Time consuming process

2) Prediction and actuality might not be in line

3) You must keep track of it constantly

 5 APPLICATIONS

A personal finance app can help track your spending, saving, investing and bill

payments while keeping you updated on credit score changes.

We can connect personal finance apps to our financial institutions to see where

the money from your bank account is being spent.

6 CONCLUSION

As the pieces of commodities are skyrocketing, we need to plan our expenses to stay

afloat. Also, checking your income and expenditures in essential to stay ahead of the

tide.

The app allows user to keep track of their expenses and accounts, and provides an

overview of their financial status. The project has options to add expenses, set the limits

and view the records.

 7 FUTURE SCOPE

The Money Matters app can be further improved by adding more features on the financial

management of an individual. The App should be able to advise on investment strategies, debt

management and offer personalized finance solutions. It should help consumers stay on top of

their credit scores by creating an app that provides real-time updates on their credit scores.
 8 APPENDIX

// User.kt

package com.example.expensestracker

import androidx.room.ColumnInfo

import androidx.room.Entity

import androidx.room.PrimaryKey

@Entity(tableName = "user_table")

data class User(

@PrimaryKey(autoGenerate = true) val id: Int?,

@ColumnInfo(name = "first_name") val firstName: String?,

@ColumnInfo(name = "last_name") val lastName: String?,

@ColumnInfo(name = "email") val email: String?,

@ColumnInfo(name = "password") val password: String?,

// UserDao.kt
package com.example.expensestracker

import androidx.room.*

@Dao

interface UserDao {

@Query("SELECT * FROM user_table WHERE email = :email")

suspend fun getUserByEmail(email: String): User?

@Insert(onConflict = OnConflictStrategy.REPLACE)

suspend fun insertUser(user: User)

@Update

suspend fun updateUser(user: User)

@Delete

suspend fun deleteUser(user: User)

// UserDatabase.kt

package com.example.expensestracker
import android.content.Context

import androidx.room.Database

import androidx.room.Room

import androidx.room.RoomDatabase

@Database(entities = [User::class], version = 1)

abstract class UserDatabase : RoomDatabase() {

abstract fun userDao(): UserDao

companion object {

@Volatile

private var instance: UserDatabase? = null

fun getDatabase(context: Context): UserDatabase {

return instance ?: synchronized(this) {

val newInstance = Room.databaseBuilder(

context.applicationContext,

UserDatabase::class.java,

"user_database"

).build()
 instance = newInstance

newInstance

// UserDatabaseHelper.kt

package com.example.expensestracker

import android.annotation.SuppressLint

import android.content.ContentValues

import android.content.Context

import android.database.Cursor

import android.database.sqlite.SQLiteDatabase

import android.database.sqlite.SQLiteOpenHelper

class UserDatabaseHelper(context: Context) :

SQLiteOpenHelper(context, DATABASE_NAME, null,

DATABASE_VERSION) {

companion object {

private const val DATABASE_VERSION = 1

private const val DATABASE_NAME = "UserDatabase.db"

 private const val TABLE_NAME = "user_table"

private const val COLUMN_ID = "id"

private const val COLUMN_FIRST_NAME = "first_name"

private const val COLUMN_LAST_NAME = "last_name"

private const val COLUMN_EMAIL = "email"

private const val COLUMN_PASSWORD = "password"

override fun onCreate(db: SQLiteDatabase?) {

val createTable = "CREATE TABLE $TABLE_NAME (" +

"$COLUMN_ID INTEGER PRIMARY KEY AUTOINCREMENT, "

+

"$COLUMN_FIRST_NAME TEXT, " +

"$COLUMN_LAST_NAME TEXT, " +

"$COLUMN_EMAIL TEXT, " +

"$COLUMN_PASSWORD TEXT" +

")"

db?.execSQL(createTable)

}
 override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int,
newVersion: Int) {

db?.execSQL("DROP TABLE IF EXISTS $TABLE_NAME")

onCreate(db)

fun insertUser(user: User) {

val db = writableDatabase

val values = ContentValues()

values.put(COLUMN_FIRST_NAME, user.firstName)

values.put(COLUMN_LAST_NAME, user.lastName)

values.put(COLUMN_EMAIL, user.email)

values.put(COLUMN_PASSWORD, user.password)

db.insert(TABLE_NAME, null, values)

db.close()

@SuppressLint("Range")

fun getUserByUsername(username: String): User? {

val db = readableDatabase

val cursor: Cursor = db.rawQuery("SELECT * FROM

$TABLE_NAME WHERE $COLUMN_FIRST_NAME = ?", arrayOf(username))

var user: User? = null

 if (cursor.moveToFirst()) {

user = User(

id =
cursor.getInt(cursor.getColumnIndex(COLUMN_ID)),

firstName =
cursor.getString(cursor.getColumnIndex(COLUMN_FIRST_NAME)),

lastName =
cursor.getString(cursor.getColumnIndex(COLUMN_LAST_NAME)),

email =
cursor.getString(cursor.getColumnIndex(COLUMN_EMAIL)),

password =
cursor.getString(cursor.getColumnIndex(COLUMN_PASSWORD)),

cursor.close()

db.close()

return user

@SuppressLint("Range")

fun getUserById(id: Int): User? {

val db = readableDatabase

val cursor: Cursor = db.rawQuery("SELECT * FROM

$TABLE_NAME WHERE $COLUMN_ID = ?", arrayOf(id.toString()))

var user: User? = null

 if (cursor.moveToFirst()) {

user = User(

id =
cursor.getInt(cursor.getColumnIndex(COLUMN_ID)),

firstName =
cursor.getString(cursor.getColumnIndex(COLUMN_FIRST_NAME)),

lastName =
cursor.getString(cursor.getColumnIndex(COLUMN_LAST_NAME)),

email =
cursor.getString(cursor.getColumnIndex(COLUMN_EMAIL)),

password =
cursor.getString(cursor.getColumnIndex(COLUMN_PASSWORD)),

cursor.close()

db.close()

return user

@SuppressLint("Range")

fun getAllUsers(): List<User> {

val users = mutableListOf<User>()

val db = readableDatabase
 val cursor: Cursor = db.rawQuery("SELECT * FROM
$TABLE_NAME", null)

if (cursor.moveToFirst()) {

do {

val user = User(

id =
cursor.getInt(cursor.getColumnIndex(COLUMN_ID)),

firstName =
cursor.getString(cursor.getColumnIndex(COLUMN_FIRST_NAME)),

lastName =
cursor.getString(cursor.getColumnIndex(COLUMN_LAST_NAME)),

email =
cursor.getString(cursor.getColumnIndex(COLUMN_EMAIL)),

password =
cursor.getString(cursor.getColumnIndex(COLUMN_PASSWORD)),

users.add(user)

} while (cursor.moveToNext())

cursor.close()

db.close()

return users

}
}