feat: implements backend of the settings modal

src-tauri/src/database/mod.rs

@@ -1,2 +1,3 @@
 pub mod note;
+pub mod setting;
 pub mod user;

src-tauri/src/database/setting.rs

@@ -0,0 +1,101 @@
+use crate::model::setting::Setting;
+use crate::model::{DatabaseManager, SqliteManager};
+use crate::schema::settings::dsl::settings;
+use diesel::{insert_into, prelude::*};
+use serde::{Deserialize, Serialize};
+use tauri::State;
+
+use crate::{
+    schema::settings::dsl::id as setting_id,
+    schema::settings::dsl::run_on_background as setting_run_on_background,
+    schema::settings::dsl::sync as setting_sync,
+};
+
+#[derive(Serialize, Deserialize)]
+pub struct ParsedSetting {
+    pub id: i32,
+    pub sync: bool,
+    #[serde(rename = "runOnBackground")]
+    pub run_on_background: bool,
+}
+
+impl ParsedSetting {
+    fn parse(setting: Setting) -> ParsedSetting {
+        ParsedSetting {
+            id: setting.id,
+            sync: i16_to_bool(setting.sync),
+            run_on_background: i16_to_bool(setting.run_on_background),
+        }
+    }
+}
+
+#[tauri::command]
+pub fn get_setting(state: State<DatabaseManager<SqliteManager>>) -> Result<ParsedSetting, String> {
+    let connection = &mut state.pool.get().map_err(|err| err.to_string())?;
+
+    let result = settings
+        .select(Setting::as_select())
+        .first(connection)
+        .optional()
+        .map_err(|err| err.to_string())?;
+
+    let setting = match result {
+        Some(setting) => setting,
+        None => create_setting(true, true, state)?,
+    };
+
+    Ok(ParsedSetting::parse(setting))
+}
+
+#[tauri::command]
+pub fn set_setting(
+    sync: bool,
+    run_on_background: bool,
+    state: State<DatabaseManager<SqliteManager>>,
+) -> Result<ParsedSetting, String> {
+    let connection = &mut state.pool.get().map_err(|err| err.to_string())?;
+
+    let updated_setting = diesel::update(settings.filter(setting_id.eq(1)))
+        .set((
+            setting_sync.eq(bool_to_i16(sync)),
+            setting_run_on_background.eq(bool_to_i16(run_on_background)),
+        ))
+        .returning(Setting::as_returning())
+        .get_result(connection)
+        .map_err(|err| err.to_string())?;
+
+    Ok(ParsedSetting::parse(updated_setting))
+}
+
+fn create_setting(
+    sync: bool,
+    run_on_background: bool,
+    state: State<DatabaseManager<SqliteManager>>,
+) -> Result<Setting, String> {
+    let connection = &mut state.pool.get().map_err(|err| err.to_string())?;
+
+    let result = insert_into(settings)
+        .values((
+            setting_sync.eq(bool_to_i16(sync)),
+            setting_run_on_background.eq(bool_to_i16(run_on_background)),
+        ))
+        .returning(Setting::as_returning())
+        .get_result(connection)
+        .map_err(|err| err.to_string())?;
+
+    Ok(result)
+}
+
+fn bool_to_i16(v: bool) -> i16 {
+    match v {
+        true => 1,
+        false => 0,
+    }
+}
+
+fn i16_to_bool(v: i16) -> bool {
+    match v {
+        1 => true,
+        _ => false,
+    }
+}

src-tauri/src/main.rs

@@ -5,6 +5,7 @@ mod model;
 mod schema;
 mod services;
 use database::note::{create_note, delete_note, get_note, get_notes, update_note};
+use database::setting::{get_setting, set_setting};
 use database::user::{create_user, get_user};
 use model::{get_connection_pool, DatabaseManager};
 use services::authentication::{login, logout};
@@ -57,6 +58,8 @@ fn main() {
             create_user,
             login,
             logout,
+            get_setting,
+            set_setting,
         ])
         .system_tray(system_tray)
         .on_system_tray_event(|app, event| match event {
@@ -74,10 +77,17 @@ fn main() {
         })
         .manage(state)
         .on_window_event(|event| match event.event() {
-            WindowEvent::CloseRequested { api, .. } => {
-                api.prevent_close();
-                event.window().hide().unwrap();
-            }
+            WindowEvent::CloseRequested { api, .. } => match get_setting(event.window().state()) {
+                Ok(setting) => {
+                    if !setting.run_on_background {
+                        return;
+                    }
+
+                    api.prevent_close();
+                    event.window().hide().unwrap();
+                }
+                Err(_) => {}
+            },
             _ => {}
         })
         .run(tauri::generate_context!())

src-tauri/src/model/mod.rs

@@ -2,6 +2,7 @@ use diesel::{connection::SimpleConnection, r2d2::ConnectionManager, SqliteConnec
 use r2d2::{ManageConnection, Pool};
 
 pub mod note;
+pub mod setting;
 pub mod user;
 
 pub type SqliteManager = ConnectionManager<SqliteConnection>;
@@ -33,6 +34,11 @@ impl DatabaseManager<SqliteManager> {
                 image text not null,
                 google_id text not null
             );
+            create table if not exists settings (
+                id integer primary key not null,
+                run_on_background integer not null default 1,
+                sync integer not null default 1
+            );
         ",
             )
             .map_err(|err| err.to_string())?;

src-tauri/src/model/setting.rs

@@ -0,0 +1,11 @@
+use diesel::prelude::*;
+use serde::Serialize;
+
+#[derive(Serialize, Queryable, Selectable)]
+#[diesel(table_name = crate::schema::settings)]
+#[diesel(check_for_backend(diesel::sqlite::Sqlite))]
+pub struct Setting {
+    pub id: i32,
+    pub run_on_background: i16,
+    pub sync: i16,
+}

src-tauri/src/schema.rs

@@ -1,5 +1,3 @@
-// @generated automatically by Diesel CLI.
-
 diesel::table! {
     notes (id) {
         id -> Integer,
@@ -17,3 +15,11 @@ diesel::table! {
         google_id -> Text,
     }
 }
+
+diesel::table! {
+    settings (id) {
+        id -> Integer,
+        run_on_background -> SmallInt,
+        sync -> SmallInt,
+    }
+}

src/components/Sidebar/components/SettingsModal/index.tsx

@@ -3,6 +3,7 @@ import { useTheme } from 'styled-components';
 import Switch from 'react-switch';
 import Modal from '../../../Modal';
 import { useAuth } from '../../../../contexts/authContext';
+import settingsService from '../../../../services/settingsService';
 import { ModalProps, UserSettings } from '../../../../types';
 import {
 	Container,
@@ -38,17 +39,16 @@ export default function SettingsModal({
 	}, [visible]);
 
 	useEffect(() => {
-		function getSettings() {
-			setSettings({
-				runOnBackground: true,
-				sync: logged ? true : false
-			});
+		async function getSettings() {
+			const setting = await settingsService.getSetting();
+			setSettings(setting);
 		}
 
 		getSettings();
 	}, [logged, visible]);
 
-	function saveSettings() {
+	async function saveSettings() {
+		await settingsService.setSetting(settings);
 		onCloseRequest();
 	}
 

src/pages/EditionPage/index.tsx

@@ -2,7 +2,7 @@ import { useEffect, useState } from 'react';
 import { useNavigate, useParams } from 'react-router-dom';
 import { faCheck } from '@fortawesome/free-solid-svg-icons';
 import Header from '../../components/Header';
-import database from '../../services/database';
+import notesService from '../../services/notesService';
 import { EditionPageParams, PopoverOption } from '../../types';
 import { Container, InputsArea, TitleInput, ContentInput } from './styles';
 import FixedButton from '../../components/FixedButton';
@@ -24,22 +24,22 @@ export default function EditionPage(): React.ReactElement {
 	];
 
 	useEffect(() => {
-		database.getNote(parseInt(noteId as string)).then((note) => {
+		notesService.getNote(parseInt(noteId as string)).then((note) => {
 			setTitle(note.title);
 			setContent(note.content);
 		});
 	}, [noteId]);
 
 	function updateNote() {
-		database.updateNote({
+		notesService.updateNote({
 			id: parseInt(noteId as string),
 			title,
 			content
 		});
 	}
 
 	function removeNote() {
-		database.deleteNote(parseInt(noteId as string));
+		notesService.deleteNote(parseInt(noteId as string));
 		navigate('/');
 	}
 

src/pages/HomePage/index.tsx

@@ -3,7 +3,7 @@ import { useNavigate } from 'react-router-dom';
 import { faPlus } from '@fortawesome/free-solid-svg-icons';
 import Sidebar from '../../components/Sidebar';
 import FixedButton from '../../components/FixedButton';
-import database from '../../services/database';
+import database from '../../services/notesService';
 import {
 	Container,
 	NotesArea,

src/pages/NewNotesPage/index.tsx

@@ -2,7 +2,7 @@ import { useState } from 'react';
 import { useNavigate } from 'react-router-dom';
 import { faCheck } from '@fortawesome/free-solid-svg-icons';
 import Header from '../../components/Header';
-import database from '../../services/database';
+import database from '../../services/notesService';
 import { Container, InputsArea, TitleInput, ContentInput } from './styles';
 import { PopoverOption } from '../../types';
 import FixedButton from '../../components/FixedButton';

src/services/database.ts → src/services/notesService.ts

@@ -1,7 +1,7 @@
 import { invoke } from '@tauri-apps/api/tauri';
 import { Note, NoteDraft, NotesProvider, QueryParams } from '../types';
 
-class DatabaseService implements NotesProvider {
+class NoteseService implements NotesProvider {
 	async createNote(data: NoteDraft) {
 		const note = await invoke<Note>('create_note', { ...data });
 
@@ -31,4 +31,4 @@ class DatabaseService implements NotesProvider {
 	}
 }
 
-export default new DatabaseService();
+export default new NoteseService();

src/services/settingsService.ts

@@ -0,0 +1,20 @@
+import { invoke } from '@tauri-apps/api/tauri';
+import { UserSettings, SettingsProvider } from '../types';
+
+class SettingsService implements SettingsProvider {
+	async getSetting() {
+		const setting = await invoke<UserSettings>('get_setting');
+
+		return setting;
+	}
+
+	async setSetting(settings: UserSettings) {
+		const updatedSetting = await invoke<UserSettings>('set_setting', {
+			...settings
+		});
+
+		return updatedSetting;
+	}
+}
+
+export default new SettingsService();

src/types/index.ts

@@ -94,3 +94,8 @@ export interface UserSettings {
 	sync: boolean;
 	runOnBackground: boolean;
 }
+
+export interface SettingsProvider {
+	setSetting: (settings: UserSettings) => Promise<UserSettings>;
+	getSetting: () => Promise<UserSettings>;
+}