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

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

Fix files

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