varnitgoyal95/address-verification-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

TP-84794 | Clickstream and customer image removed from watermelon DB

Browse Source
This commit is contained in:
yashmantri
2024-09-20 01:13:55 +05:30
parent c210c30e03
commit c5532ab3db
9 changed files with 19 additions and 313 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
src/services/clickstreamEventService.ts
View File

@@ -1,15 +1,11 @@
import { ApiKeys, API_URLS } from './../components/utlis/apiHelper';
import { API_URLS } from './../components/utlis/apiHelper';
import {
getAppVersion,
getEventNameFromAPIKey,
getKeyByValue,
getParamsObject,
} from './../components/utlis/commonFunctions';
import React from 'react';
import axiosInstance from '../components/utlis/apiHelper';
import { getNetInfo } from '../components/utlis/commonFunctions';
import { GLOBAL } from '../constants/Global';
import ClickStreamEventsDAO, { IClickstreamEvent } from '../wmDB/dao/ClickStreamEventsDAO';
import {
NetInfoCellularGeneration,
NetInfoState,
@@ -23,8 +19,20 @@ import { SCREEN_HEIGHT, SCREEN_WIDTH } from '@rn-ui-lib/styles';
export type ClickstreamDesc = { name: string; description: string };
export interface IClickstreamEvent {
event_name: string;
description: string;
timestamp: number;
agentId: string;
deviceId: string;
attributes?: unknown;
networkStatus: string;
appVersion: string;
isOnline: boolean;
batteryLevel: string;
}
const MAX_BUFFER_SIZE_FOR_API = 10;
const MAX_BUFFER_SIZE_FOR_DB_WRITE = 20;
let eventsList: IClickstreamEvent[] = [];
let bufferEventsList: IClickstreamEvent[] = [];
@@ -48,9 +56,6 @@ const addEvent = async (networkStatus: string) => {
if (eventsList.length > MAX_BUFFER_SIZE_FOR_API) {
if (networkStatus !== 'offline') {
fireClickstreamEvents();
} else if (eventsList.length > MAX_BUFFER_SIZE_FOR_DB_WRITE) {
await ClickStreamEventsDAO.addEventsBulk(eventsList);
eventsList = [];
}
}
};
@@ -122,40 +127,9 @@ const fireClickstreamEvents = async () => {
const url = JANUS_SERVICE_URL;
bufferEventsList = [...eventsList];
eventsList = [];
const payload = await getPayload(bufferEventsList);
const clickstreamEventsFromDB = await ClickStreamEventsDAO.getAllEvents();
const events = clickstreamEventsFromDB
.map((item: IClickstreamEvent) => {
const {
deviceId,
agentId,
event_name,
attributes,
timestamp,
networkStatus,
appVersion,
isOnline,
batteryLevel,
} = item;
return {
deviceId,
agentId,
event_name,
attributes,
timestamp,
networkStatus,
appVersion,
isOnline,
batteryLevel,
};
})
.concat(bufferEventsList);
const payload = await getPayload(events);
axiosInstance
.post(url, payload, { headers: { donotHandleError: true } })
.then(() => ClickStreamEventsDAO.deleteAllEvents());
axiosInstance.post(url, payload, { headers: { donotHandleError: true } });
};
export const sendApiToClickstreamEvent = (
@@ -171,7 +145,7 @@ export const sendApiToClickstreamEvent = (
const eventName = getEventNameFromAPIKey(apiKey, isSuccess);
addClickstreamEvent(
{ name: eventName, description: eventName },
{ timeTaken: milliseconds, statusCode, response: statusCode === 400 ? response : '' }
{ timeTaken: milliseconds, statusCode, response: statusCode === 400 ? response : '' }
);
}
}

2
src/wmDB/const.ts
View File

@@ -1,7 +1,5 @@
export enum TableName {
OFFLINE_IMAGES = 'offline_image',
CUSTOMER_IMAGE = 'customer_image',
CLICKSTREAM_EVENTS = 'clickstream_events',
}
export const DB_VERSION = 6;

116
src/wmDB/dao/ClickStreamEventsDAO.ts
View File

@@ -1,116 +0,0 @@
import { database } from '../db';
import { Q } from '@nozbe/watermelondb';
import { TableName } from '../const';
import { logError } from '../../components/utlis/errorUtils';
const clickStreamEvents = database.get(TableName.CLICKSTREAM_EVENTS);
export interface IClickstreamEvent {
event_name: string;
description: string;
timestamp: number;
agentId: string;
deviceId: string;
attributes?: unknown;
networkStatus: string;
appVersion: string;
isOnline: boolean;
batteryLevel: string;
}
export default {
observeOfflineImage: () => clickStreamEvents.query().observe(),
addEvent: async (
event_name: string,
timestamp: number,
description: string,
agentId: string,
deviceId: string,
attributes: any,
networkStatus: string,
appVersion: string,
isOnline: boolean,
batteryLevel: string
) => {
try {
return await database.action(async () => {
return await clickStreamEvents.create((event: any) => {
event.event_name = event_name;
event.description = description;
event.timestamp = timestamp;
event.deviceId = deviceId;
event.agentId = agentId;
event.attributes = attributes;
event.networkStatus = networkStatus;
event.appVersion = appVersion;
event.isOnline = isOnline;
event.batteryLevel = batteryLevel;
});
});
} catch (e) {
console.log(e);
}
},
addEventsBulk: async (events: Array<IClickstreamEvent>) => {
function prepareInsertion(events: Array<IClickstreamEvent>) {
return events.map((clickStreamEvent) => {
const {
event_name,
deviceId,
attributes,
agentId,
timestamp,
description,
networkStatus,
isOnline,
appVersion,
batteryLevel,
} = clickStreamEvent;
try {
return clickStreamEvents.prepareCreate((event: any) => {
event.event_name = event_name;
event.description = description;
event.timestamp = timestamp;
event.deviceId = deviceId;
event.agentId = agentId;
event.attributes = attributes;
event.networkStatus = networkStatus;
event.isOnline = isOnline;
event.appVersion = appVersion;
event.batteryLevel = batteryLevel;
});
} catch (e) {
logError(e as Error, 'WM DB');
}
});
}
try {
return await database.action(async () => {
const allRecords = prepareInsertion(events);
await database.batch(...allRecords);
});
} catch (e) {
logError(e as Error, 'WM DB');
}
},
getAllEvents: async () => {
try {
return await database.action(async () => {
return await clickStreamEvents.query().fetch();
});
} catch (e) {
console.log(e);
return;
}
},
deleteAllEvents: async () => {
try {
return await database.action(async () => {
await clickStreamEvents.query().destroyAllPermanently();
});
} catch (e) {
console.log(e);
return;
}
},
};

93
src/wmDB/dao/CustomerImageDAO.ts
View File

@@ -1,93 +0,0 @@
import { database } from '../db';
import { Q } from '@nozbe/watermelondb';
import { TableName } from '../const';
import { logError } from '../../components/utlis/errorUtils';
const customerImage = database.get(TableName.CUSTOMER_IMAGE);
interface ICustomerOfflineImage {
caseId: string;
imageURL: string;
image64: string;
}
export default {
observeOfflineImage: () => customerImage.query().observe(),
addBulkCustomerImage: async (customerImageList: ICustomerOfflineImage[]) => {
function prepareInsertion(customerImageList: ICustomerOfflineImage[]) {
return customerImageList.map((customerImageItem) => {
try {
return customerImage.prepareCreate((imageRow: any) => {
imageRow.caseId = customerImageItem.caseId;
imageRow.imageURL = customerImageItem.imageURL;
imageRow.image64 = customerImageItem.image64;
});
} catch (e) {
logError(e as Error, 'WM DB');
}
});
}
try {
return await database.action(async () => {
const allRecords = prepareInsertion(customerImageList);
await database.batch(...allRecords);
});
} catch (e) {
logError(e as Error, 'WM DB');
}
},
addCustomerImage: async (customerImageItem: ICustomerOfflineImage) => {
try {
return await database.action(async () => {
return await customerImage.create((imageRow: any) => {
imageRow.caseId = customerImageItem.caseId;
imageRow.imageURL = customerImageItem.imageURL;
imageRow.image64 = customerImageItem.image64;
});
});
} catch (e) {
logError(e as Error, 'WM DB');
}
},
getImageByURL: async (imageURL: string) => {
try {
return await database.action(async () => {
return await customerImage.query(Q.where('image_url', imageURL), Q.take(1)).fetch();
});
} catch (e) {
logError(e as Error, 'WM DB');
return;
}
},
getImageByCase: async (caseId: string) => {
try {
return await database.action(async () => {
return await customerImage.query(Q.where('case_id', caseId), Q.take(1)).fetch();
});
} catch (e) {
logError(e as Error, 'WM DB');
return;
}
},
deleteImages: async (caseIds: Array<string> | string) => {
let tCaseIds = Array.isArray(caseIds) ? caseIds : [caseIds];
try {
return await database.action(async () => {
await customerImage.query(Q.where('case_id', Q.oneOf(tCaseIds))).destroyAllPermanently();
});
} catch (e) {
logError(e as Error, 'WM DB');
return;
}
},
deleteAll: async () => {
try {
return await database.action(async () => {
await customerImage.query().destroyAllPermanently();
});
} catch (e) {
logError(e as Error, 'WM DB');
return;
}
},
};

4
src/wmDB/db.ts
View File

@@ -1,8 +1,6 @@
import { Database } from '@nozbe/watermelondb';
import SQLiteAdapter from '@nozbe/watermelondb/adapters/sqlite';
import { DB_NAME } from './const';
import ClickstreamEvents from './model/ClickstreamEvents';
import CustomerImage from './model/CustomerImage';
import OfflineImage from './model/OfflineImage';
import schema from './schema';
@@ -14,7 +12,7 @@ const adapter = new SQLiteAdapter({
const database = new Database({
adapter,
modelClasses: [OfflineImage, CustomerImage, ClickstreamEvents],
modelClasses: [OfflineImage],
});
export { database };

4
src/wmDB/index.ts
View File

@@ -1,6 +1,4 @@
import PostDAO from './dao/OfflineImageDAO';
import CustomerImageDAO from './dao/CustomerImageDAO';
import ClickstreamDAO from './dao/ClickStreamEventsDAO';
export { database } from './db';
export { PostDAO, CustomerImageDAO, ClickstreamDAO };
export { PostDAO };

20
src/wmDB/model/ClickstreamEvents.ts
View File

@@ -1,20 +0,0 @@
import { Model } from '@nozbe/watermelondb';
import { field, json } from '@nozbe/watermelondb/decorators';
import { TableName } from '../const';
const sanitizeAttributes = (json: any) => json;
export default class ClickstreamEvents extends Model {
static table = TableName.CLICKSTREAM_EVENTS;
@field('event_name') event_name!: string;
@field('description') description!: string;
@field('agent_id') agentId!: string;
@field('device_id') deviceId!: string;
@field('network_status') networkStatus!: string;
@field('timestamp') timestamp!: number;
@json('attributes', sanitizeAttributes) attributes: any;
@field('app_version') appVersion!: string;
@field('is_online') isOnline!: boolean;
@field('battery_level') batteryLevel!: string;
}

13
src/wmDB/model/CustomerImage.ts
View File

@@ -1,13 +0,0 @@
import { Model } from '@nozbe/watermelondb';
import { field, readonly, date } from '@nozbe/watermelondb/decorators';
import { TableName } from '../const';
export default class CustomerImage extends Model {
static table = TableName.CUSTOMER_IMAGE;
@field('case_id') caseId!: string;
@field('image_url') imageURL!: string;
@field('image_64') image64!: string;
@readonly @date('created_at') createdAt!: any;
@readonly @date('updated_at') updatedAt!: any;
}

20
src/wmDB/schema.ts
View File

@@ -14,25 +14,5 @@ export default appSchema({
{ name: 'image_height', type: 'string' },
],
}),
tableSchema({
name: TableName.CUSTOMER_IMAGE,
columns: [
{ name: 'case_id', type: 'string' },
{ name: 'image_url', type: 'string' },
{ name: 'image_64', type: 'string' },
],
}),
tableSchema({
name: TableName.CLICKSTREAM_EVENTS,
columns: [
{ name: 'event_name', type: 'string' },
{ name: 'description', type: 'string' },
{ name: 'agent_id', type: 'string' },
{ name: 'device_id', type: 'string' },
{ name: 'attributes', type: 'string' },
{ name: 'network_status', type: 'string' },
{ name: 'timestamp', type: 'number' },
],
}),
],
});