1/**
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16import HiLog from '../utils/HiLog';
17import common from '../data/commonData';
18import telephoneUtil from '../utils/TelephoneUtil';
19import LooseObject from '../data/LooseObject';
20import ContactsModel from '../model/ContactsModel';
21
22const TAG = 'ContactsService';
23
24export default class ContactsService {
25    private static instance: ContactsService;
26    private contactsModel = new ContactsModel();
27
28    private constructor() {
29    }
30
31    public static getInstance(): ContactsService {
32        if (ContactsService.instance == null) {
33            ContactsService.instance = new ContactsService();
34        }
35        return ContactsService.instance;
36    }
37
38    public async queryContactDataByCondition(actionData, callback, context): Promise<void> {
39        let mmsContext = context ? context : globalThis.mmsContext;
40        if (globalThis.DataWorker != null) {
41            globalThis.DataWorker.sendRequest(common.RUN_IN_WORKER_METHOD.queryContactDataByCondition, {
42                actionData: actionData,
43                context: mmsContext
44            }, res => {
45                callback(res);
46            });
47        } else {
48            this.contactsModel.queryContactDataByCondition(actionData, callback, mmsContext);
49        }
50
51    }
52
53    public async queryContactDataSizeByCondition(actionData, callback, context): Promise<void> {
54        let mmsContext = context ? context : globalThis.mmsContext;
55        if (globalThis.DataWorker != null) {
56            globalThis.DataWorker.sendRequest(common.RUN_IN_WORKER_METHOD.queryContactDataSizeByCondition, {
57                actionData: actionData,
58                context: mmsContext
59            }, res => {
60                callback(res);
61            });
62        } else {
63            this.contactsModel.queryContactDataSizeByCondition(actionData, callback, mmsContext);
64        }
65    }
66
67    public async queryContactByCondition(actionData, callback, context): Promise<void> {
68        let mmsContext = context ? context : globalThis.mmsContext;
69        if (globalThis.DataWorker != null) {
70            globalThis.DataWorker.sendRequest(common.RUN_IN_WORKER_METHOD.queryContactByCondition, {
71                actionData: actionData,
72                context: mmsContext
73            }, res => {
74                callback(res);
75            });
76        } else {
77            this.contactsModel.queryContactByCondition(actionData, callback, mmsContext);
78        }
79    }
80
81    public async queryContactSizeByCondition(actionData, callback, context): Promise<void> {
82        let mmsContext = context ? context : globalThis.mmsContext;
83        if (globalThis.DataWorker != null) {
84            globalThis.DataWorker.sendRequest(common.RUN_IN_WORKER_METHOD.queryContactSizeByCondition, {
85                actionData: actionData,
86                context: mmsContext
87            }, res => {
88                callback(res);
89            });
90        } else {
91            this.contactsModel.queryContactSizeByCondition(actionData, callback, mmsContext);
92        }
93    }
94
95    public async queryRawContactSizeByCondition(actionData, callback, context): Promise<void> {
96        let mmsContext = context ? context : globalThis.mmsContext;
97        if (globalThis.DataWorker != null) {
98            globalThis.DataWorker.sendRequest(common.RUN_IN_WORKER_METHOD.queryRawContactSizeByCondition, {
99                actionData: actionData,
100                context: mmsContext
101            }, res => {
102                callback(res);
103            });
104        } else {
105            this.contactsModel.queryRawContactSizeByCondition(actionData, callback, mmsContext);
106        }
107    }
108
109    public async queryContactViewByCondition(actionData, callback, context): Promise<void> {
110        let mmsContext = context ? context : globalThis.mmsContext;
111        if (globalThis.DataWorker != null) {
112            globalThis.DataWorker.sendRequest(common.RUN_IN_WORKER_METHOD.queryContactViewByCondition, {
113                actionData: actionData,
114                context: mmsContext
115            }, res => {
116                callback(res);
117            });
118        } else {
119            this.contactsModel.queryContactViewByCondition(actionData, callback, mmsContext);
120        }
121    }
122
123    public queryContact(actionData, callback, context): void {
124        this.queryContactByCondition(actionData, res => {
125            if (res.code == common.int.FAILURE) {
126                callback(res);
127                return;
128            }
129            actionData.contactIds = res.abilityResult[0];
130            this.queryContactDataByCondition(actionData, res => {
131                if (res.code == common.int.FAILURE) {
132                    callback(res);
133                    return;
134                }
135                let contactList: Array<LooseObject> = this.buildContactList(res.abilityResult);
136                let result: LooseObject = {};
137                result.code = common.int.SUCCESS;
138                result.response = contactList;
139                callback(result);
140            }, context);
141        }, context);
142    }
143
144    public dealContactParams(contactObjects): LooseObject {
145        let contactParams: LooseObject = {};
146        if (contactObjects && contactObjects != common.string.EMPTY_STR) {
147            let params: Array<LooseObject> = [];
148            try {
149                params = JSON.parse(contactObjects);
150            } catch (Error) {
151                HiLog.i(TAG, `JSON.parse error ${Error}`);
152                return contactParams;
153            }
154            let contactsNumber: string = common.string.EMPTY_STR;
155            let contactsName: string = common.string.EMPTY_STR;
156            let contactsNumberFormat: string = common.string.EMPTY_STR;
157            let length: number = params.length;
158            for (let item of params) {
159                contactsNumber = contactsNumber + item.telephone + common.string.COMMA;
160                contactsNumberFormat = contactsNumberFormat + item.telephone + common.string.COMMA;
161                if (item.contactsName) {
162                    contactsName += (item.contactsName + common.string.COMMA);
163                } else if (length > 1) {
164                    contactsName += (item.telephone + common.string.COMMA);
165                }
166            }
167            let telephone: string = contactsNumber.substring(0, contactsNumber.length - 1);
168            contactsNumber = telephoneUtil.dealTelephoneSort(telephone);
169            contactParams.strContactsNumber = contactsNumber;
170            contactParams.strContactsNumberFormat = contactsNumber;
171            contactParams.strContactsName = contactsName.substring(0, contactsName.length - 1);
172            contactParams.contactsNum = length;
173        }
174        return contactParams;
175    }
176
177    public judgeContactExist(actionData, callback, context): void {
178        this.queryContactDataSizeByCondition(actionData, res => {
179            let isContactExist: boolean = false;
180            if (res.code == common.int.FAILURE) {
181                HiLog.e(TAG, 'judgeProfileExit fail!');
182                callback(isContactExist);
183            } else {
184                if (res.abilityResult > 0) {
185                    isContactExist = true;
186                }
187                callback(isContactExist);
188            }
189        }, context);
190    }
191
192    private buildContactList(contacts): Array<LooseObject> {
193        let contactList: Array<LooseObject> = [];
194        for (let contact of contacts) {
195            let item: LooseObject = {};
196            item.contactName = contact.displayName;
197            item.headImage = 'icon/user_avatar_full_fill.svg';
198            item.telephone = contact.detailInfo;
199            item.telephoneFormat = contact.detailInfo;
200            item.select = false;
201            contactList.push(item);
202        }
203        return contactList;
204    }
205}
206