jerzes/sfmlstrminglxj9f1v-2da

1import aiohttp
2from aiohttp import ClientTimeout
3import asyncio
4import subprocess
5import requests
6from datetime import datetime
7import traceback
8
9class LarkClass:
10    # Hàm khởi tạo (Constructor)
11    def __init__(self,app_id,app_secret):
12        self.tenant_token=None
13        self.user_token=None
14        self.app_token=None
15        self.app_id=app_id
16        self.app_secret=app_secret
17        self.token_created_at=None
18        self.expire=None
19        self.headers={
20            'authorization':f"Bearer {self.tenant_token or self.user_token or self.app_token}",
21        }
22
23    # Phương thức
24    async def get_tenant_token(self):
25        try:
26            now=int(datetime.now().timestamp())
27            if  not self.token_created_at or now -self.token_created_at>self.expire:
28                url='https://open.larksuite.com/open-apis/auth/v3/tenant_access_token/internal'
29                headers={}
30                data={
31                    'app_id':self.app_id,
32                    'app_secret':self.app_secret
33                }
34                async with aiohttp.ClientSession(timeout=ClientTimeout(total=30)) as session:
35                    async with session.post(url, headers=headers, json=data) as res:
36                        if res.status<400:
37                            result=await res.json()
38                            self.token_created_at=int(datetime.now().timestamp())
39                            self.expire=result['expire']
40                            self.tenant_token=result['tenant_access_token']
41                            print('Get token success')
42                            return True
43                return False
44        except Exception as err:
45            await res.release()
46            await session.close()
47            print(err)
48            traceback.print_exc()
49            return False
50    async def get_user_token(self):
51        try:
52            url='https://open.larksuite.com/open-apis/authen/v1/oidc/access_token'
53            headers={}
54            data={
55                'app_id':self.app_id,
56                'app_secret':self.app_secret
57            }
58            async with aiohttp.ClientSession(timeout=ClientTimeout(total=30)) as session:
59                async with session.post(url, headers=headers, json=data) as res:
60                    if res.status<400:
61                        print('Get token success')
62                        result=await res.json()
63                        return result
64            return False
65        except Exception as err:
66            await res.release()
67            await session.close()
68            print(err)
69            traceback.print_exc()
70            return False
71        
72    async def get_app_token(self):
73        try:
74            url='https://open.larksuite.com/open-apis/auth/v3/app_access_token/internal'
75            headers={}
76            data={
77                'app_id':self.app_id,
78                'app_secret':self.app_secret
79            }
80            async with aiohttp.ClientSession(timeout=ClientTimeout(total=30)) as session:
81                async with session.post(url, headers=headers, json=data) as res:
82                    if res.status<400:
83                        print('Get token success')
84                        result=await res.json()
85                        return result
86            return False
87        except Exception as err:
88            await res.release()
89            await session.close()
90            print(err)
91            traceback.print_exc()
92            return False
93    async def create_new_request(self, method, url, data=None):
94        await self.get_tenant_token()
95        headers = {
96            'authorization': f"Bearer {self.tenant_token or self.user_token or self.app_token}",
97        }
98        try:
99            async with aiohttp.ClientSession(timeout=ClientTimeout(total=30)) as session:
100                if method.lower() == "get":
101                    response = await session.get(url, headers=headers)
102                elif method.lower() == "post":
103                    response = await session.post(url, headers=headers, json=data)
104                elif method.lower() == "put":
105                    response = await session.put(url, headers=headers, json=data)
106                elif method.lower() == "delete":
107                    if data:
108                        response = await session.delete(url, headers=headers, json=data)
109                    else:
110                        response = await session.delete(url, headers=headers)
111                else:
112                    raise ValueError(f"Unsupported method: {method}")
113                # Đảm bảo giải phóng kết nối đúng cách
114                if response.status < 400:
115                    result = await response.json()
116                    if 'data' in result:
117                        return result['data']
118                    print(result)
119                if 'x-ogw-ratelimit-reset' in response.headers:
120                    return {'status': 'error', 'msg': f"Rate limit is exceeded, reconnect in {response.headers['x-ogw-ratelimit-reset']}", 'reconnect_after': int(response.headers['x-ogw-ratelimit-reset'])}
121        except Exception as err:
122            print(err)
123            traceback.print_exc()
124            return False
125    async def list_files(self,folder_token):
126        result=await self.create_new_request('get',f"https://open.larksuite.com/open-apis/drive/v1/files?folder_token="+folder_token)
127        return result
128    async def create_app(self,folder_token,name):
129        data={
130            "name":name,
131            "folder_token": folder_token
132        }
133        result=await self.create_new_request('post','https://open.larksuite.com/open-apis/bitable/v1/apps',data)
134        return result
135    async def create_table(self,app_token,table_name,fields):
136        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables"
137        data={
138            "table":{
139                "name":table_name,
140                "default_view_name":"Grid",
141                "fields":fields
142            }
143        }
144        result=await self.create_new_request(method='post',url=url,data=data)
145        return result
146    async def get_tables(self,app_token):
147        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables"
148        result=await self.create_new_request(method='get',url=url)
149        if result:
150            return result['items']
151        return False
152    async def delete_table(self,app_token,table_id):
153        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}"
154        result=await self.create_new_request(method='delete',url=url)
155        if result:
156            return result
157        return False
158    async def get_list_record(self,app_token,table_id,page_size=500,page_token=None):
159        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records?page_size={page_size}"+(f"&page_token={page_token}" if page_token else '')
160        result=await self.create_new_request(method='get',url=url)
161        if result:
162            return result
163        return False
164    async def create_new_record(self,app_token,table_id,value_fields):
165        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records"
166        data={
167            "fields":value_fields
168        }
169        result=await self.create_new_request(method='post',url=url,data=data)
170        if result:
171            return result
172        return False
173    async def get_record(self,app_token,table_id,record_id):
174        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/{record_id}"
175        result=await self.create_new_request(method='get',url=url)
176        if result:
177            return result
178        return False
179    async def update_record(self,app_token,table_id,record_id,value_fields):
180        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/{record_id}"
181        data={
182            "fields":value_fields
183        }
184        result=await self.create_new_request(method='put',url=url,data=data)
185        if result:
186            return result
187        return False
188    async def delete_record(self,app_token,table_id,record_id):
189        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/{record_id}"
190        result=await self.create_new_request(method='delete',url=url)
191        if result:
192            return result
193        return False
194    async def create_new_records(self,app_token,table_id,array_value):
195        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/batch_create"
196        data={
197            "records":array_value
198        }
199        result=await self.create_new_request(method='post',url=url,data=data)
200        if result:
201            return result
202        return False
203    async def update_records(self,app_token,table_id,array_value):
204        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/batch_update"
205        data={
206            "records":array_value
207        }
208        result=await self.create_new_request(method='post',url=url,data=data)
209        if result:
210            return result
211        return False
212    async def delete_records(self,app_token,table_id,array_record_id):
213        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/batch_delete"
214        data={
215            'records':array_record_id
216        }
217        result=await self.create_new_request(method='post',url=url,data=data)
218        if result:
219            return result
220        return False
221    async def get_list_fields(self,app_token,table_id,page_size=100,page_token=None):
222        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/fields?page_size={page_size}"+(f"page_token={page_token}" if page_token else '')
223        result=await self.create_new_request(method='get',url=url)
224        if result:
225            return result
226        return False
227    async def get_bot_info(self):
228        url=f"https://open.larksuite.com/open-apis/bot/v3/info"
229        headers={
230            'authorization':f"Bearer {self.tenant_token or self.user_token or self.app_token}",
231        }
232        async with aiohttp.ClientSession() as session:
233            result = await session.get(url, headers=headers)
234            if result.status<400:
235                js=await result.json()
236                return js['bot']
237        return False
238    async def search_record(self,app_token,table_id,conditions_array,page_size=500,page_token=None,conjunction='and'):
239        url=f"https://open.larksuite.com/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/search?page_size={page_size}"+(f'&page_token={page_token}' if page_token else '')
240        headers={
241            'authorization':f"Bearer {self.tenant_token or self.user_token or self.app_token}",
242        }
243        data={
244            "filter": {
245                "conjunction": conjunction,
246                "conditions": conditions_array
247            },
248        }
249        result=await self.create_new_request(method='post',url=url,data=data)
250        if result:
251            return result
252        return False
253    async def download_file(self,url,file_name):
254        headers={
255            'authorization':f"Bearer {self.tenant_token or self.user_token or self.app_token}",
256        }
257        try:
258            response = requests.get(url,headers=headers)
259            if response.status_code == 200:
260                content_type = response.headers.get('Content-Type')
261                if 'image' in content_type:
262                    file_extension = '.' + content_type.split('/')[1]
263                elif 'video' in content_type: 
264                    file_extension = '.' + content_type.split('/')[1]
265                elif 'pdf' in content_type:
266                    file_extension = '.pdf'
267                elif 'text' in content_type:
268                    file_extension = '.txt'
269                else:
270                    file_extension = '.bin'
271                file_name = file_name + file_extension
272                with open(file_name, 'wb') as file:
273                    file.write(response.content)
274                print(f"Tệp đã được tải xuống thành công và lưu thành {file_name}.")
275                return file_name
276            else:
277                print(f"Lỗi tải tệp: {response.status_code}")
278        except Exception as err:
279            print(f'Can\'t download file. Error- {err}')
280        return False