universal_bot-ts

1
import {IDbControllerResult, IModelRes,} from '../../../../src/models';
2
import {DbControllerModel, IQueryData, QueryData} from '../../../../src/models/db';
3
import {Request} from '../../../../src/api';
4

5
export default class DbConnect extends DbControllerModel {
6

7
    protected _query: Request;
8

9
    constructor() {
10
        super();
11
        this._query = new Request();
12
        this._query.url = 'https://query.ru/query';
13
    }
14

15
    /**
16
     * Приводим полученный результат из запроса к требуемому виду.
17
     * В данном случае, ожидаем что полученные данные будут вида:
18
     * {
19
     *  'key': 'value'
20
     * }
21
     * @param res
22
     */
23
    getValue(res: IModelRes): IDbControllerResult {
24
        return res.data;
25
    }
26

27
    /**
28
     * Отправляем запрос на добавление данных
29
     *
30
     * @param insertData
31
     */
32
    insert(insertData: QueryData) {
33
        this._query.post = {
34
            type: 'insert',
35
            table: this.tableName,
36
            data: insertData
37
        };
38
        const res = this._query.send();
39
        return new Promise<IModelRes>((resolve) => {
40
            res.then(res => {
41
                if (res.status) {
42
                    resolve({
43
                        status: true,
44
                        data: res.data
45
                    });
46
                } else {
47
                    resolve({
48
                        status: false,
49
                        error: res.err
50
                    });
51
                }
52
            });
53
        });
54
    }
55

56
    /**
57
     * Проверяем наличие подключения
58
     */
59
    isConnected(): Promise<boolean> {
60
        return Promise.resolve(true);
61
    }
62

63
    /**
64
     * Выполняем произвольный запрос
65
     *
66
     * @param callback
67
     */
68
    query(callback: Function) {
69
        this._query.post = {
70
            type: 'query',
71
            table: this.tableName,
72
            query: callback
73
        };
74
        const res = this._query.send();
75
        return new Promise<IModelRes>((resolve) => {
76
            res.then(res => {
77
                if (res.status) {
78
                    resolve({
79
                        status: true,
80
                        data: res.data
81
                    });
82
                } else {
83
                    resolve({
84
                        status: false,
85
                        error: res.err
86
                    });
87
                }
88
            });
89
        });
90
    }
91

92
    /**
93
     * Выполняем запрос на удаление данных
94
     *
95
     * @param removeData
96
     */
97
    remove(removeData: QueryData) {
98
        this._query.post = {
99
            type: 'delete',
100
            table: this.tableName,
101
            data: removeData
102
        };
103
        const res = this._query.send();
104
        return new Promise<IModelRes>((resolve) => {
105
            res.then(res => {
106
                if (res.status) {
107
                    resolve({
108
                        status: true,
109
                        data: res.data
110
                    });
111
                } else {
112
                    resolve({
113
                        status: false,
114
                        error: res.err
115
                    });
116
                }
117
            });
118
        });
119
    }
120

121
    /**
122
     * Выполняем запрос на сохранение данных.
123
     * Тут суть в том, что если данных для обновления нет, то будет добавлена новая запись.
124
     *
125
     * @param saveData
126
     * @param isNew
127
     */
128
    save(saveData: QueryData, isNew: boolean) {
129
        this._query.post = {
130
            type: 'save',
131
            table: this.tableName,
132
            data: saveData
133
        };
134
        const res = this._query.send();
135
        return new Promise<IModelRes>((resolve) => {
136
            res.then(res => {
137
                if (res.status) {
138
                    resolve({
139
                        status: true,
140
                        data: res.data
141
                    });
142
                } else {
143
                    resolve({
144
                        status: false,
145
                        error: res.err
146
                    });
147
                }
148
            });
149
        });
150
    }
151

152
    /**
153
     * Отправляем запрос на получение данных
154
     * @param select
155
     * @param isOne
156
     */
157
    select(select: IQueryData | null, isOne: boolean): Promise<IModelRes> {
158
        this._query.post = {
159
            type: 'select',
160
            table: this.tableName,
161
            select
162
        };
163
        const res = this._query.send();
164
        return new Promise<IModelRes>((resolve) => {
165
            res.then(res => {
166
                if (res.status) {
167
                    let data: any = res.data;
168
                    if (isOne) {
169
                        data = data[0];
170
                    }
171
                    resolve({
172
                        status: true,
173
                        data
174
                    });
175
                } else {
176
                    resolve({
177
                        status: false,
178
                        error: res.err
179
                    });
180
                }
181
            });
182
        });
183
    }
184

185
    /**
186
     * Выполняем запрос на обновление данных
187
     *
188
     * @param updateData
189
     */
190
    update(updateData: QueryData) {
191
        this._query.post = {
192
            type: 'update',
193
            table: this.tableName,
194
            data: updateData
195
        };
196
        const res = this._query.send();
197
        return new Promise<IModelRes>((resolve) => {
198
            res.then(res => {
199
                if (res.status) {
200
                    resolve({
201
                        status: true,
202
                        data: res.data
203
                    });
204
                } else {
205
                    resolve({
206
                        status: false,
207
                        error: res.err
208
                    });
209
                }
210
            });
211
        });
212
    }
213
}
214