ldc-com-app/ComApp/src/App/Controllers/SyncController.js

// Lodash
import _ from 'lodash';
// Http Client
import axios from 'axios';
// Network Infos
import NetInfo from "@react-native-community/netinfo";
// Application infos
import * as Application from 'expo-application';
// Database 
import { Setting, Contact, SendBrochure, Document } from '../../Database';

const api_token = 'toto';
const app_uuid = '1f6eda31-1f6d-49fe-aa81-4f0aece0f7ca';
const url = "https://dev-app.rhd-ldc.fr";

class SyncController {

    async checkConnection() {
        NetInfo.fetch().then(state => {
            return state.isConnected;
        });
        return false;
    }

    async getVersion() {
        return axios({
            method: 'GET',
            url: url + '/api/version',
            responseType: 'json',
            params: {
                token: api_token,
                app_uuid: app_uuid,
                app_version: Application.nativeApplicationVersion
            },
        });
    }

    async getUsers() {
        return axios({
            method: 'GET',
            url: url + '/api/users',
            responseType: 'json',
            params: {
                token: api_token
            },
        });
    }

    async getContacts(userId) {
        let contacts = Contact.getAll();
        return axios({
            method: 'POST',
            url: url + '/api/contacts',
            responseType: 'json',
            params: {
                token: api_token
            },
            data: {
                contacts: contacts,
                userId: userId,
            }
        });
    }

    async sendBrochures() {
        let brochures = SendBrochure.getAll();
        for (const brochure of brochures) {
            await axios({
                method: 'POST',
                url: url + '/api/sendBrochure',
                responseType: 'json',
                params: {
                    token: api_token,
                    emails: brochure,
                },
            });
        }
        SendBrochure.clear();
    }

    async getDirectories() {
        return axios({
            method: 'GET',
            url: url + '/api/directories',
            responseType: 'json',
            params: {
                token: api_token
            },
        });
    }

    async getDocuments() {
        return axios({
            method: 'GET',
            url: url + '/api/documents',
            responseType: 'json',
            params: {
                token: api_token,
            },
        });
    }

    updateLastModificationDoc(id, date) {
        Document.update({ id: id, updated_at: date.toString() }, true);
    }

    updateVersion(version) {
        const localVersion = Setting.get('version');
        if (localVersion === false || localVersion === undefined) {
            Setting.add({ key: 'version', value: version });
        } else {
            Setting.update({ id: localVersion.id, key: 'version', value: version });
        }
    }

    updateShowIsActive(value) {
        const local = Setting.get('ShowIsActive');
        if (local === false || local === undefined) {
            Setting.add({ key: 'ShowIsActive', value: value });
        } else {
            Setting.update({ id: local.id, key: 'ShowIsActive', value: value });
        }
    }

    isSynced() {
        const SendBrochure = SendBrochure.getAll();
        const Contacts = Contact.getAll();

        if (SendBrochure !== undefined && Contacts !== undefined) {
            const noSynced = Contacts.filtered('synced = false');
            if (SendBrochure.length > 0 || noSynced.length > 0) {
                return false;
            }
        }
        return true;
    }

    isLogged() {
        const logged = Setting.get('isLogged');
        const loggedTime = Setting.get('loggedTime');
        if (
            logged !== false &&
            loggedTime !== false &&
            logged !== undefined &&
            loggedTime !== undefined
        ) {
            let seconds =
                Math.abs(new Date(Number(loggedTime.value)) - Date.now()) / 1000;
            if (seconds < 14400) {
                // 4h
                return true;
            }
            return false;
        }
        return false;
    }
}

export default new SyncController();