source: bell-scheduler/trunk/fuentes/n4d-bellscheduler.install/usr/share/n4d/python-plugins/BellSchedulerManager.py @ 6871

Last change on this file since 6871 was 6871, checked in by jrpelegrina, 19 months ago

Fix files and added translations

File size: 9.6 KB
Line 
1 
2import os
3import json
4import codecs
5import shutil
6import xmlrpclib as n4dclient
7import ssl
8import zipfile
9
10
11class BellSchedulerManager(object):
12
13        def __init__(self):
14
15                self.config_dir=os.path.expanduser("/etc/bellScheduler/")
16                self.config_file=self.config_dir+"bell_list"
17                self.cron_dir="/etc/scheduler/tasks.d/"
18                self.cron_file=os.path.join(self.cron_dir,"BellScheduler")
19
20                self.images_folder="/usr/local/share/bellScheduler/images"
21                self.sounds_folder="/usr/local/share/bellScheduler/sounds"
22                self.media_files_folder="/usr/local/share/bellScheduler/"
23       
24
25                server='localhost'
26                context=ssl._create_unverified_context()
27                self.n4d = n4dclient.ServerProxy("https://"+server+":9779",context=context,allow_none=True)
28               
29                self._get_n4d_key()
30
31
32        #def __init__   
33
34
35        def _get_n4d_key(self):
36
37                self.n4dkey=''
38                with open('/etc/n4d/key') as file_data:
39                        self.n4dkey = file_data.readlines()[0].strip()
40
41        #def _get_n4d_key
42
43        def _create_conf(self):
44
45                if not os.path.exists(self.config_dir):
46                        os.makedirs(self.config_dir)
47
48                if not os.path.exists(self.images_folder):
49                        os.makedirs(self.images_folder)
50
51                if not os.path.exists(self.sounds_folder):
52                        os.makedirs(self.sounds_folder)         
53               
54                var={}
55                with codecs.open(self.config_file,'w',encoding="utf-8") as f:
56                        json.dump(var,f,ensure_ascii=False)
57                        f.close()
58
59                return {"status":True,"msg":"Configuration file created successfuly"}
60
61        #def create_conf               
62       
63
64        def read_conf(self):
65               
66                if not os.path.exists(self.config_file):
67                        self._create_conf()
68               
69                f=open(self.config_file)
70               
71                try:
72                        self.bells_config=json.load(f)
73                except Exception as e:
74
75                        self.bells_config={}
76                        return {"status":False,"msg":"Unabled to read configuration file :" +str(e),"code":25,"data":self.bells_config}
77
78
79                f.close()       
80
81                return {"status":True,"msg":"Configuration file readed successfuly","code":26,"data":self.bells_config}
82
83        #def read_conf 
84
85        def _get_tasks_from_cron(self):
86
87                cron_tasks={}
88                tmp_tasks={}
89                tasks=self.n4d.get_local_tasks(self.n4dkey,'SchedulerServer')
90               
91                if tasks["status"]:
92
93                        for item in tasks["data"]:
94                                if item=="BellScheduler":
95                                                tmp_tasks=tasks["data"][item]
96
97                        if len(tmp_tasks)>0:
98                                for     item in tmp_tasks:
99                                        key=str(tmp_tasks[item]["BellId"])
100                                        cron_tasks[key]={}
101                                        cron_tasks[key]["CronId"]=item
102               
103                return cron_tasks
104
105        #def _get_tasks_from_cron       
106               
107       
108        def sync_with_cron(self):
109       
110                bell_tasks=self.read_conf()["data"]
111                keys_cron=self._get_tasks_from_cron().keys()
112                changes=0
113
114                if len(keys_cron)>0:
115                        for item in bell_tasks:
116                                if item in keys_cron:
117                                        if bell_tasks[item]["active"]:
118                                                pass
119                                        else:
120                                                changes+=1
121                                                bell_tasks[item]["active"]=True
122                                else:
123                                        if bell_tasks[item]["active"]:
124                                                changes+=1
125                                                bell_tasks[item]["active"]=False
126                                        else:
127                                                pass
128                else:
129                        for item in bell_tasks:
130                                if bell_tasks[item]["active"]:
131                                        changes+=1
132                                        bell_tasks[item]["active"]=False
133                                       
134                if changes>0:
135                        self._write_conf(bell_tasks)
136
137                return {"status":True,"msg":"Sync with cron sucessfully","data":bell_tasks}                             
138
139        #def sync_with_cron     
140
141        def _write_conf(self,info):
142               
143                self.bells_config=info
144               
145                with codecs.open(self.config_file,'w',encoding="utf-8") as f:
146                        json.dump(info,f,ensure_ascii=False)
147                        f.close()       
148
149                return {"status":True,"msg":"Bell list saved successfuly"}     
150
151
152        #def _write_conf       
153
154        def save_changes(self,info,last_change,action):
155               
156                turn_on=False
157                if action !="remove":
158                        if info[last_change]["active"]:
159                                turn_on=True
160                                tasks_for_cron=self._format_to_cron(info,last_change,action)
161                                result=self.n4d.write_tasks(self.n4dkey,'SchedulerServer','local',tasks_for_cron)
162
163                        else:
164                                result=self._delete_from_cron(last_change)
165                else:
166                        result=self._delete_from_cron(last_change)
167
168
169                if result['status']:   
170                        return self._write_conf(info)
171                else:
172                        if action=="edit":
173                                return {"status":False,"action":action,"msg":result['data'],"code":19} 
174                        elif action=="add":
175                                return {"status":False,"action":action,"msg":result['data'],"code":20}
176                        elif action=="remove":
177                                return {"status":False,"action":action,"msg":result['data'],"code":21} 
178                        elif action=="active": 
179                                if turn_on:
180                                        return {"status":False,"action":action,"msg":result['data'],"code":22}
181                                else:
182                                        return {"status":False,"action":action,"msg":result['data'],"code":23}
183               
184        #def save_changes                               
185
186        def _get_cron_id(self,last_change):
187
188                cron_tasks=self._get_tasks_from_cron()
189                if len(cron_tasks)>0:
190                        if last_change in cron_tasks.keys():
191                                return {"status":True, "id":cron_tasks[last_change]}
192               
193                return {"status":False,"id":{"CronId":0}}
194
195        # def _get_cron_id     
196       
197        def _delete_from_cron(self,last_change):
198
199                id_to_remove=self._get_cron_id(last_change)
200                cron_id=id_to_remove["id"]["CronId"]
201                delete={"status":True,"data":"0"}
202
203                if id_to_remove["status"]:
204                        delete=self.n4d.remove_task(self.n4dkey,'SchedulerServer','local','BellScheduler',cron_id,'cmd')
205                       
206                return delete
207
208        #def _delete_from_cron 
209       
210        def _format_to_cron(self,info,item,action):
211
212                info_to_cron={}
213               
214       
215                if action=="edit" or action=="active":
216                        cron_tasks=self._get_tasks_from_cron()
217                        try:
218                                key=cron_tasks[item]["CronId"]
219                        except:
220                                key="0" 
221                else:
222                        key="0"
223                       
224                info_to_cron["BellScheduler"]={}
225                info_to_cron["BellScheduler"][key]={}
226                info_to_cron["BellScheduler"][key]["name"]=info[item]["name"]
227                info_to_cron["BellScheduler"][key]["dom"]="*"
228                info_to_cron["BellScheduler"][key]["mon"]="*" 
229                info_to_cron["BellScheduler"][key]["h"]=str(info[item]["hour"])
230                info_to_cron["BellScheduler"][key]["m"]=str(info[item]["minute"])
231                info_to_cron["BellScheduler"][key]["protected"]=True
232
233                weekdays=info[item]["weekdays"]
234                days=""
235                if weekdays["0"]:
236                        days=days+"1,"
237                if weekdays["1"]:
238                        days=days+"2,"
239                if weekdays["2"]:
240                        days=days+"3,"
241                if weekdays["3"]:
242                        days=days+"4,"
243                if weekdays["4"]:
244                        days=days+"5,"
245
246                if days!="":
247                        days=days[:-1]
248
249                else:
250                        days='*'
251
252                info_to_cron["BellScheduler"][key]["dow"]=days
253                info_to_cron["BellScheduler"][key]["BellId"]=item                               
254
255               
256                sound_option=info[item]["sound"]["option"]
257                sound_path=info[item]["sound"]["path"]
258                duration=info[item]["play"]["duration"]
259
260                fade_out=int(duration)-2
261                fade_effects='-af afade=in:st=1:d=3,afade=out:st='+str(fade_out)+":d=2"
262                cmd="ffplay -nodisp -autoexit -t "+str(duration)
263
264                if sound_option !="url":
265                        if sound_option =="file":
266                                cmd=cmd+" '"+sound_path+"' "+fade_effects
267                                print(cmd)
268                        else:
269                                cmd=cmd+" $(find"+ " '"+sound_path+"' -type f | shuf -n 1) "+fade_effects               
270                else:
271                        cmd=cmd+ " $(youtube-dl -g "+sound_path+ " | sed -n 2p) "+fade_effects
272                       
273                info_to_cron["BellScheduler"][key]["cmd"]=cmd
274                       
275                return info_to_cron
276
277        #def _format_to_cron   
278
279        def copy_media_files(self,image,sound):
280
281
282                if image!="":
283                        image_file=os.path.basename(image)
284                        image_dest=os.path.join(self.images_folder,image_file)
285
286                if sound!="":
287                        sound_file=os.path.basename(sound)
288                        sound_dest=os.path.join(self.sounds_folder,sound_file)
289
290                try:
291                        if image!="":
292                                if not os.path.exists(image_dest):
293                                        shutil.copy2(image,image_dest)
294
295                        if sound!="":
296                                if not os.path.exists(sound_dest):
297                                        shutil.copy2(sound,sound_dest)
298
299                        result={"status":True,"msg":"Files copied successfully"}
300                except Exception as e:
301                                result={"status":False,"msg":str(e),"code":24}         
302
303                return result
304       
305        #def copy_media_files
306
307        def export_bells_conf(self,dest_file,user,arg=None):
308
309                tmp_export=tempfile.mkdtemp("_bell_export")
310               
311                try:
312                        shutil.copy2(self.config_file,os.path.join(tmp_export,os.path.basename(self.config_file)))
313                        if os.path.exists(self.cron_file):
314                                shutil.copy2(self.cron_file,os.path.join(tmp_export,os.path.basename(self.cron_file)))
315                        if os.path.exists(self.media_files_folder):
316                                shutil.copytree(self.media_files_folder,os.path.join(tmp_export,"media"))
317                       
318                        shutil.make_archive(dest_file, 'zip', tmp_export)
319                        if arg!=True:
320                                shutil.rmtree(tmp_export)
321
322                        cmd='chown -R '+user+':'+user +" " + dest_file+'.zip'
323                        os.system(cmd) 
324                        result={"status":True,"msg":"Bells exported successfullly","code":11}
325                                               
326                except Exception as e:
327                        result={"status":False,"msg":str(e),"code":12}         
328
329                return result   
330
331        #def export_bells_conf 
332
333        def import_bells_conf(self,orig_file,user,backup):
334
335                backup_file=["",""]
336                unzip_tmp=tempfile.mkdtemp("_import_bells")
337                result={"status":True}
338
339                if backup:
340                        backup_file=tempfile.mkstemp("_bells_backup")
341                        result=self.export_bells_conf(backup_file[1],user,True)
342
343                try:   
344                        if result['status']:   
345                                tmp_zip=zipfile.ZipFile(orig_file)
346                                tmp_zip.extractall(unzip_tmp)
347                                tmp_zip.close   
348
349                                config_file=os.path.join(unzip_tmp,os.path.basename(self.config_file)) 
350                                if os.path.exists(config_file):
351                                        try:
352                                                f=open(config_file)
353                                                read=json.load(f)
354                                                shutil.copy2(config_file,self.config_dir)
355                                                f.close()
356                                        except Exception as e:
357                                                result={"status":False,"msg":str(e),"code":9,"data":backup_file[1]}     
358                                                return result           
359                                                       
360                                cron_file=os.path.join(unzip_tmp,os.path.basename(self.cron_file))
361                                if os.path.exists(cron_file):
362                                        try:
363                                                f=open(cron_file)
364                                                read=json.load(f)
365                                                shutil.copy2(cron_file,self.cron_dir)
366                                                f.close()
367                                        except Exception as e:
368                                                result={"status":False,"msg":str(e),"code":9,"data":backup_file[1]}     
369                                                return result   
370
371                                if os.path.exists(self.images_folder):
372                                        shutil.rmtree(self.images_folder)
373                                        shutil.copytree(os.path.join(unzip_tmp,"media/images"),self.images_folder)
374
375                                if os.path.exists(self.sounds_folder):
376                                        shutil.rmtree(self.sounds_folder)
377                                        shutil.copytree(os.path.join(unzip_tmp,"media/sounds"),self.sounds_folder)
378               
379
380                                result={"status":True,"msg":"Bells imported successfullly","code":10,"data":backup_file[1]}
381                                                               
382                except Exception as e:
383                        result={"status":False,"msg":str(e),"code":9,"data":backup_file[1]}     
384
385               
386                return result           
387
388        #def import_bells_conf
Note: See TracBrowser for help on using the repository browser.