5620530640

Committed 21 Jul 2023 08:57AM UTC coverage: 73.627% (-0.07%) from 73.699%

Build # 5620530640

Build Type

push

github

Committed by

wayangalihpratama

Commit Message

[#64] Implement syncFormSubmission fn on task manager

Run Details

392 of 567 branches covered (69.14%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

895 of 1181 relevant lines covered (75.78%)

7.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.19

/app/src/lib/background-task.js

import { crudForms, crudSessions, crudDataPoints, crudUsers } from '../database/crud';
import api from './api';
import * as BackgroundFetch from 'expo-background-fetch';
import * as TaskManager from 'expo-task-manager';

const syncFormVersion = async ({
  showNotificationOnly = true,
  sendPushNotification = () => {},
}) => {
  try {
    // find last session
    const session = await crudSessions.selectLastSession();
    if (!session) {
      return;
    }
    const authenticationCode = session.passcode;
    const data = new FormData();
    data.append('code', authenticationCode);
    api
      .post('/auth', data, { headers: { 'Content-Type': 'multipart/form-data' } })
      .then(async (res) => {
        const { data } = res;
        const promises = data.formsUrl.map(async (form) => {
          const formExist = await crudForms.selectFormByIdAndVersion({ ...form });
          if (formExist) {
            return false;
          }
          if (showNotificationOnly) {
            console.info('[bgTask]New form:', form.id, form.version);
            return { id: form.id, version: form.version };
          }
          const formRes = await api.get(form.url);
          // update previous form latest value to 0
          await crudForms.updateForm({ ...form });
          console.info('[syncForm]Updated Forms...', form.id);
          const savedForm = await crudForms.addForm({ ...form, formJSON: formRes?.data });
          console.info('[syncForm]Saved Forms...', form.id);
          return savedForm;
        });
        Promise.all(promises).then(async (res) => {
          const exist = res.filter((x) => x);
          if (!exist.length || !showNotificationOnly) {
            return;
          }
          sendPushNotification();
        });
      });
  } catch (err) {
    console.error('[bgTask]sycnFormVersion failed:', err);
  }
};

const registerBackgroundTask = async (TASK_NAME, minimumInterval = 86400) => {
  try {
    await BackgroundFetch.registerTaskAsync(TASK_NAME, {
      minimumInterval: minimumInterval,
      stopOnTerminate: true, // android only,
      startOnBoot: true, // android only
    });
  } catch (err) {
    console.error('Task Register failed:', err);
  }
};

const unregisterBackgroundTask = async (TASK_NAME) => {
  try {
    await BackgroundFetch.unregisterTaskAsync(TASK_NAME);
  } catch (err) {
    console.error('Task Unregister failed:', err);
  }
};

const backgroundTaskStatus = async (TASK_NAME, minimumInterval = 86400) => {
  const status = await BackgroundFetch.getStatusAsync();
  const isRegistered = await TaskManager.isTaskRegisteredAsync(TASK_NAME);
  if (BackgroundFetch.BackgroundFetchStatus?.[status] === 'Available' && !isRegistered) {
    await registerBackgroundTask(TASK_NAME, minimumInterval);
  }
  console.log(`[${TASK_NAME}] Status`, status, isRegistered, minimumInterval);
};

const syncFormSubmission = async () => {
  try {
    // get token
    const session = await crudSessions.selectLastSession();
    // set token
    api.setToken(session.token);
    // get all datapoints to sync
    const data = await crudDataPoints.selectSubmissionToSync();
    console.info('[syncFormSubmisiion] data point to sync:', data.length);
    data.forEach(async (d) => {
      // get user
      const user = await crudUsers.selectUserById({ id: d.user });
      const syncData = {
        name: d.name,
        submitter: user.name,
        duration: d.duration,
        submittedAt: d.submittedAt,
        answers: JSON.parse(d.json.replace(/''/g, "'")),
      };
      // sync data point
      const res = await api.post('/sync', syncData);
      console.info('[syncFormSubmisiion] post sync data point:', res.status, res.data);
      if (res.status === 200) {
        // update data point
        await crudDataPoints.updateDataPoint({
          ...d,
          syncedAt: new Date().toISOString(),
        });
        console.info('[syncFormSubmisiion] updated data point syncedAt:', d.id);
      }
    });
  } catch (err) {
    console.error('[syncFormSubmission] Error: ', err);
  }
};

const backgroundTaskHandler = () => {
  return {
    syncFormVersion,
    registerBackgroundTask,
    unregisterBackgroundTask,
    backgroundTaskStatus,
    syncFormSubmission,
  };
};

const backgroundTask = backgroundTaskHandler();
export default backgroundTask;

1	import { crudForms, crudSessions, crudDataPoints, crudUsers } from '../database/crud';
2	import api from './api';
3	import * as BackgroundFetch from 'expo-background-fetch';
4	import * as TaskManager from 'expo-task-manager';
5
6	const syncFormVersion = async ({	7✔
7	showNotificationOnly = true,	×
8	sendPushNotification = () => {},	×
9	}) => {
10	try {	2✔
11	// find last session
12	const session = await crudSessions.selectLastSession();	2✔
13	if (!session) {	2!
14	return;	×
15	}
16	const authenticationCode = session.passcode;	2✔
17	const data = new FormData();	2✔
18	data.append('code', authenticationCode);	2✔
19	api	2✔
20	.post('/auth', data, { headers: { 'Content-Type': 'multipart/form-data' } })
21	.then(async (res) => {
22	const { data } = res;	2✔
23	const promises = data.formsUrl.map(async (form) => {	2✔
24	const formExist = await crudForms.selectFormByIdAndVersion({ ...form });	2✔
25	if (formExist) {	2!
26	return false;	×
27	}
28	if (showNotificationOnly) {	2✔
29	console.info('[bgTask]New form:', form.id, form.version);	1✔
30	return { id: form.id, version: form.version };	1✔
31	}
32	const formRes = await api.get(form.url);	1✔
33	// update previous form latest value to 0
34	await crudForms.updateForm({ ...form });	1✔
35	console.info('[syncForm]Updated Forms...', form.id);	1✔
36	const savedForm = await crudForms.addForm({ ...form, formJSON: formRes?.data });	1✔
37	console.info('[syncForm]Saved Forms...', form.id);	1✔
38	return savedForm;	1✔
39	});
40	Promise.all(promises).then(async (res) => {	2✔
41	const exist = res.filter((x) => x);	2✔
42	if (!exist.length \|\| !showNotificationOnly) {	2✔
43	return;	1✔
44	}
45	sendPushNotification();	1✔
46	});
47	});
48	} catch (err) {
49	console.error('[bgTask]sycnFormVersion failed:', err);	×
50	}
51	};
52
53	const registerBackgroundTask = async (TASK_NAME, minimumInterval = 86400) => {	7✔
54	try {	2✔
55	await BackgroundFetch.registerTaskAsync(TASK_NAME, {	2✔
56	minimumInterval: minimumInterval,
57	stopOnTerminate: true, // android only,
58	startOnBoot: true, // android only
59	});
60	} catch (err) {
61	console.error('Task Register failed:', err);	×
62	}
63	};
64
65	const unregisterBackgroundTask = async (TASK_NAME) => {	7✔
66	try {	1✔
67	await BackgroundFetch.unregisterTaskAsync(TASK_NAME);	1✔
68	} catch (err) {
69	console.error('Task Unregister failed:', err);	×
70	}
71	};
72
73	const backgroundTaskStatus = async (TASK_NAME, minimumInterval = 86400) => {	7✔
74	const status = await BackgroundFetch.getStatusAsync();	1✔
75	const isRegistered = await TaskManager.isTaskRegisteredAsync(TASK_NAME);	1✔
76	if (BackgroundFetch.BackgroundFetchStatus?.[status] === 'Available' && !isRegistered) {	1!
77	await registerBackgroundTask(TASK_NAME, minimumInterval);	1✔
78	}
79	console.log(`[${TASK_NAME}] Status`, status, isRegistered, minimumInterval);	1✔
80	};
81
82	const syncFormSubmission = async () => {	7✔
83	try {	1✔
84	// get token
85	const session = await crudSessions.selectLastSession();	1✔
86	// set token
87	api.setToken(session.token);	1✔
88	// get all datapoints to sync
89	const data = await crudDataPoints.selectSubmissionToSync();	1✔
90	console.info('[syncFormSubmisiion] data point to sync:', data.length);	1✔
91	data.forEach(async (d) => {	1✔
92	// get user
93	const user = await crudUsers.selectUserById({ id: d.user });	1✔
94	const syncData = {	1✔
95	name: d.name,
96	submitter: user.name,
97	duration: d.duration,
98	submittedAt: d.submittedAt,
99	answers: JSON.parse(d.json.replace(/''/g, "'")),
100	};
101	// sync data point
102	const res = await api.post('/sync', syncData);	1✔
103	console.info('[syncFormSubmisiion] post sync data point:', res.status, res.data);	1✔
104	if (res.status === 200) {	1!
105	// update data point
106	await crudDataPoints.updateDataPoint({	1✔
107	...d,
108	syncedAt: new Date().toISOString(),
109	});
110	console.info('[syncFormSubmisiion] updated data point syncedAt:', d.id);	1✔
111	}
112	});
113	} catch (err) {
114	console.error('[syncFormSubmission] Error: ', err);	×
115	}
116	};
117
118	const backgroundTaskHandler = () => {	7✔
119	return {	7✔
120	syncFormVersion,
121	registerBackgroundTask,
122	unregisterBackgroundTask,
123	backgroundTaskStatus,
124	syncFormSubmission,
125	};
126	};
127
128	const backgroundTask = backgroundTaskHandler();	7✔
129	export default backgroundTask;

akvo / nmis-mobile / 5620530640

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous