Changeset 7743


Ignore:
Timestamp:
Jul 17, 2018, 2:22:55 PM (15 months ago)
Author:
jrpelegrina
Message:

WIP in new features and improve performance

Location:
bell-scheduler/trunk/fuentes
Files:
1 added
9 edited

Legend:

Unmodified
Added
Removed
  • bell-scheduler/trunk/fuentes/bell-scheduler-indicator.install/usr/bin/bell-scheduler-indicator

    r7546 r7743  
    3535        WATCH_DIR=os.path.expanduser("/tmp/.BellScheduler")
    3636        TARGET_FILE="/tmp/.BellScheduler/bellscheduler-token"
     37        FRECUENCY=2
    3738
    3839        def __init__(self,icon_name):
     
    6768                self.start_inotify()
    6869               
    69                 GLib.timeout_add_seconds(5, self.worker)
     70                GLib.timeout_add_seconds(BellSchedulerIndicator.FRECUENCY, self.worker)
    7071               
    7172
     
    222223                error=True
    223224
    224                 bell_info=self.n4d.read_conf("",'BellSchedulerManager')
    225 
    226                 if bell_info["status"]:         
    227 
    228                         if os.path.exists(BellSchedulerIndicator.TARGET_FILE):
    229                                 f=open(BellSchedulerIndicator.TARGET_FILE,'r')
    230                                 bell_id=f.readline().split('\n')[0]
    231                                 f.close()
    232 
    233                                 if len(bell_info["data"])>0:
    234                                         try:
    235                                                 self.info["name"]=bell_info["data"][bell_id]["name"]
    236                                                 hour=bell_info["data"][bell_id]["hour"]
    237                                                 minute=bell_info["data"][bell_id]["minute"]
    238                                                 format_hour=self._format_hour(hour,minute)
    239                                                 self.info["hour"]=format_hour
    240                                                 duration=bell_info["data"][bell_id]["play"]["duration"]
    241                                                 if duration==0:
    242                                                         duration=_("Full reproduction")
    243                                                 else:
    244                                                         duration=str(duration)+""+seconds_label
    245                                                 self.info["duration"]=duration
    246                                                 error=False
    247                                         except:
    248                                                 pass
     225                try:
     226                        bell_info=self.n4d.read_conf("",'BellSchedulerManager')
     227
     228                        if bell_info["status"]:         
     229
     230                                if os.path.exists(BellSchedulerIndicator.TARGET_FILE):
     231                                        f=open(BellSchedulerIndicator.TARGET_FILE,'r')
     232                                        bell_id=f.readline().split('\n')[0]
     233                                        f.close()
     234
     235                                        if len(bell_info["data"])>0:
     236                                                try:
     237                                                        self.info["name"]=bell_info["data"][bell_id]["name"]
     238                                                        hour=bell_info["data"][bell_id]["hour"]
     239                                                        minute=bell_info["data"][bell_id]["minute"]
     240                                                        format_hour=self._format_hour(hour,minute)
     241                                                        self.info["hour"]=format_hour
     242                                                        duration=bell_info["data"][bell_id]["play"]["duration"]
     243                                                        if duration==0:
     244                                                                duration=_("Full reproduction")
     245                                                        else:
     246                                                                duration=str(duration)+""+seconds_label
     247                                                        self.info["duration"]=duration
     248                                                        error=False
     249                                                except:
     250                                                        pass
     251                except:
     252                        pass                           
    249253
    250254                if error:
  • bell-scheduler/trunk/fuentes/bell-scheduler/python3-bellscheduler/EditBox.py

    r7647 r7743  
    4848
    4949                self.css_file=self.core.rsrc_dir+"bell-scheduler.css"
    50 
    5150                self.main_box=builder.get_object("bell_edit_box")
    5251                self.cron_frame=builder.get_object("cron_frame")
     
    6766                self.image_fc=builder.get_object("image_filechosser")
    6867                self.sound_label=builder.get_object("sound_label")
    69                 self.random_rb=builder.get_object("random_radiobutton")
     68                self.directory_rb=builder.get_object("directory_radiobutton")
    7069                self.file_rb=builder.get_object("file_radiobutton")
    7170                self.url_rb=builder.get_object("url_radiobutton")
     71                self.listurl_rb=builder.get_object("listurl_radiobutton")
    7272                self.sound_dc=builder.get_object("sound_folderchosser")
    7373                self.sound_fc=builder.get_object("sound_filechosser")
    7474                self.sound_url=builder.get_object("url_entry")
     75                self.sound_listurl=builder.get_object("listurl_filechosser")
    7576
    7677                self.duration_label=builder.get_object("duration_label")
     
    8485                self.weekdays.append(self.thursday_tb)
    8586                self.weekdays.append(self.friday_tb)
     87
     88                self.image_rb_list=[]
     89                self.image_rb_list.append(self.stock_rb)
     90                self.image_rb_list.append(self.custom_rb)
     91
     92                self.sound_rb_list=[]
     93                self.sound_rb_list.append(self.file_rb)
     94                self.sound_rb_list.append(self.directory_rb)
     95                self.sound_rb_list.append(self.url_rb)
     96                self.sound_rb_list.append(self.listurl_rb)
    8697               
    8798                self.image_cb=builder.get_object("image_combobox")
     
    132143                self.stock_rb.connect("toggled",self.image_toggled_button,"stock")
    133144                self.custom_rb.connect("toggled",self.image_toggled_button,"custom")
    134                 self.random_rb.connect("toggled",self.sound_toggled_button,"random")
     145                self.directory_rb.connect("toggled",self.sound_toggled_button,"directory")
    135146                self.file_rb.connect("toggled",self.sound_toggled_button,"file")
    136147                self.url_rb.connect("toggled",self.sound_toggled_button,"url")
     148                self.listurl_rb.connect("toggled",self.sound_toggled_button,"listurl")
    137149                self.image_fc.connect("file-set",self.check_mimetype_image)
    138150                self.sound_fc.connect("file-set",self.check_mimetype_sound)
     
    143155
    144156                self.checking_data_t=threading.Thread(target=self.checking_data)
    145 
    146157                self.checking_data_t.daemon=True
    147 
    148                 self.checking_data_t.launched=False
    149 
    150158                GObject.threads_init()
    151159               
     
    155163
    156164                self.image_op="stock"
     165                self.image_cb.set_active(0)
    157166                self.image_fc.set_sensitive(False)
    158167                self.sound_op="file"
    159168                self.sound_dc.set_sensitive(False)
    160169                self.sound_url.set_sensitive(False)
     170                self.sound_listurl.set_sensitive(False)
    161171                self.duration_entry.set_value(30)
    162172                self.init_threads()
     
    184194
    185195                if button.get_active():
    186                         if name=="random":
     196                        if name=="directory":
    187197                                self.sound_dc.set_sensitive(True)
    188198                                self.sound_fc.set_sensitive(False)
    189199                                self.sound_url.set_sensitive(False)
    190                                 self.sound_op="random"
    191 
    192                         else:
    193                                 if name=="file":
    194                                         self.sound_dc.set_sensitive(False)
    195                                         self.sound_fc.set_sensitive(True)
    196                                         self.sound_url.set_sensitive(False)
    197                                         self.sound_op="file"
    198                                 else:
    199                                         self.sound_dc.set_sensitive(False)
    200                                         self.sound_fc.set_sensitive(False)
    201                                         self.sound_url.set_sensitive(True)     
    202                                         self.sound_op="url"     
     200                                self.sound_listurl.set_sensitive(False)
     201                                self.sound_op="directory"
     202                        elif name=="file":
     203                                self.sound_dc.set_sensitive(False)
     204                                self.sound_fc.set_sensitive(True)
     205                                self.sound_url.set_sensitive(False)
     206                                self.sound_listurl.set_sensitive(False)
     207                                self.sound_op="file"
     208                        elif name=="url":
     209                                self.sound_dc.set_sensitive(False)
     210                                self.sound_fc.set_sensitive(False)
     211                                self.sound_url.set_sensitive(True)
     212                                self.sound_listurl.set_sensitive(False)
     213                                self.sound_op="url"
     214                        elif name=="listurl":
     215                                self.sound_dc.set_sensitive(False)
     216                                self.sound_fc.set_sensitive(False)
     217                                self.sound_url.set_sensitive(False)
     218                                self.sound_listurl.set_sensitive(True) 
     219                                self.sound_op="listurl"         
    203220
    204221        #def sound_toggled_button                                       
     
    243260                sound_op=bell_to_edit["sound"]["option"]
    244261
    245                 if sound_op=="random":
    246                         self.random_rb.set_active(True)
     262                if sound_op=="directory":
     263                        self.directory_rb.set_active(True)
    247264                        if os.path.exists(bell_to_edit["sound"]["path"]):
    248265                                self.sound_dc.set_filename(bell_to_edit["sound"]["path"])
     
    251268                        if os.path.exists(bell_to_edit["sound"]["path"]):
    252269                                self.sound_fc.set_filename(bell_to_edit["sound"]["path"])       
    253                 else:
     270                elif sound_op=="url":
    254271                        self.url_rb.set_active(True)
    255272                        self.sound_url.set_text(bell_to_edit["sound"]["path"])
     273                elif sound_op=="listurl":
     274                        self.listurl_rb.set_active(True)
     275                        if os.path.exists(bell_to_edit["sound"]["path"]):
     276                                self.sound_listurl.set_filename(bell_to_edit["sound"]["path"])         
    256277
    257278                self.duration_entry.set_value(bell_to_edit["play"]["duration"])
     
    265286        def gather_values(self,widget):
    266287
    267                 self.files_tocheck={}
    268                 self.files_tocheck["sound"]=""
    269                 self.files_tocheck["image"]=""
    270                 self.files_tocheck["url"]=None
    271                 self.files_tocheck["directory"]=""
     288                self.core.mainWindow.msg_label.set_text("")
     289                self.data_tocheck={}
     290                self.data_tocheck["name"]=self.name_entry.get_text()
     291                self.data_tocheck["image"]={}
     292                self.data_tocheck["image"]["option"]=self.image_op
     293                self.data_tocheck["sound"]={}
     294                self.data_tocheck["sound"]["option"]=self.sound_op
     295
     296                self.core.mainWindow.save_button.set_sensitive(False)
     297                self.core.mainWindow.cancel_button.set_sensitive(False)
     298                self.manage_form_control(True)
    272299
    273300               
     
    276303                else:
    277304                        self.image_path=self.image_fc.get_filename()
    278                         self.files_tocheck["image"]=self.image_path
    279 
    280                 if self.sound_op=="random":
     305                        self.data_tocheck["image"]["file"]=self.image_path
     306
     307                if self.sound_op=="directory":
    281308                        self.sound_path=self.sound_dc.get_filename()
    282                         self.files_tocheck["directory"]=self.sound_path
     309                        self.data_tocheck["sound"]["file"]=self.sound_path
    283310                elif self.sound_op=="file":
    284311                        self.sound_path=self.sound_fc.get_filename()
    285                         self.files_tocheck["sound"]=self.sound_path
    286                 else:   
    287                         self.sound_path=self.sound_url.get_text()
    288                         self.files_tocheck["url"]=self.sound_path
     312                        self.data_tocheck["sound"]["file"]=self.sound_path
     313                elif self.sound_op=="url":     
     314                        self.sound_path=self.sound_url.get_text().split('\n')[0]
     315                        self.data_tocheck["sound"]["file"]=self.sound_path
     316                elif self.sound_op=="listurl":
     317                        self.sound_path=self.sound_listurl.get_filename()
     318                        self.data_tocheck["sound"]["file"]=self.sound_path     
    289319                       
    290320                self.duration=self.duration_entry.get_value_as_int()
     
    306336                else:
    307337                        self.core.mainWindow.waiting_window.hide()
     338                       
    308339                        if not self.check["result"]:
    309                                 self.core.mainWindow.manage_message(True,self.check["code"])
     340                                self.core.mainWindow.save_button.set_sensitive(True)
     341                                self.core.mainWindow.cancel_button.set_sensitive(True)
     342                                self.manage_form_control(False)
     343                                self.core.mainWindow.manage_message(True,self.check["code"],self.check["data"])
    310344                        else:   
    311345                                self.save_values()
     
    317351        def checking_data(self):
    318352               
    319                 self.check=self.core.bellmanager.check_data(self.name_entry.get_text(),self.files_tocheck)
     353                self.check=self.core.bellmanager.check_data(self.data_tocheck)
    320354       
    321355        #def checking_data
     
    323357        def save_values(self):         
    324358               
     359                '''
     360                Result code:
     361                        -15: edited successfully
     362                        -18: created successfully
     363                '''
     364
    325365                bell=self.core.mainWindow.bells_info.copy()
    326366                order_keys=[]
     
    447487                        self.core.mainWindow.manage_message(True,check["code"])
    448488                else:
    449                         self.core.mainWindow.msg_label.hide()
     489                        self.core.mainWindow.msg_label.set_text("")
    450490
    451491        #def check_mimetype_image               
     
    457497                        self.core.mainWindow.manage_message(True,check["code"])
    458498                else:
    459                         self.core.mainWindow.msg_label.hide()
     499                        self.core.mainWindow.msg_label.set_text("")
    460500
    461501        #def check_mimetype_sound               
    462502
    463503
     504        def manage_form_control(self,disable):
     505
     506                if disable:
     507                        sensitive=False
     508                else:
     509                        sensitive=True
     510       
     511                self.hour_spinbutton.set_sensitive(sensitive)
     512                self.minute_spinbutton.set_sensitive(sensitive)
     513                for item in self.weekdays:
     514                        item.set_sensitive(sensitive)
     515
     516                self.name_entry.set_sensitive(sensitive)       
     517                for item in self.image_rb_list:
     518                        item.set_sensitive(sensitive)
     519
     520                if self.image_op=="stock":
     521                        self.image_cb.set_sensitive(sensitive)
     522                else:
     523                        self.image_fc.set_sensitive(sensitive)
     524
     525                for item in self.sound_rb_list:
     526                        item.set_sensitive(sensitive)
     527
     528                if self.sound_op=="file":
     529                        self.sound_fc.set_sensitive(sensitive)
     530                elif self.sound_op=="directory":
     531                        self.sound_dc.set_sensitive(sensitive)
     532                elif self.sound_op=="url":
     533                        self.sound_url.set_sensitive(sensitive)                 
     534                elif self.sound_op=="listurl":
     535                        self.sound_listurl.set_sensitive(sensitive)             
     536
     537                self.duration_entry.set_sensitive(sensitive)
     538
     539        #def manage_form_control       
    464540       
    465541#class EditBox
  • bell-scheduler/trunk/fuentes/bell-scheduler/python3-bellscheduler/MainWindow.py

    r7487 r7743  
    5858                self.main_window=builder.get_object("main_window")
    5959                self.main_window.set_title("Bell Scheduler")
    60                 self.main_window.resize(930,690)
     60                self.main_window.resize(930,725)
    6161                self.main_box=builder.get_object("main_box")
    6262                self.login=N4dGtkLogin()
     
    7474                self.import_button=builder.get_object("import_button")
    7575                self.manage_holiday_button=builder.get_object("manage_holiday_button")
     76                self.help_button=builder.get_object("help_button")
    7677                self.enable_holiday_label=builder.get_object("enable_holiday_label")
    7778                self.enable_holiday_switch=builder.get_object("enable_holiday_switch")
     
    174175                self.return_button.connect("clicked",self.return_button_clicked)
    175176                self.enable_holiday_switch.connect("notify::active",self.enable_holiday_switch_clicked)
     177                self.help_button.connect("clicked",self.help_clicked)
    176178
    177179        #def connect_signals   
     
    306308                        response = dialog.run()
    307309                        if response == Gtk.ResponseType.OK:
     310                                self.recovery=False
    308311                                self.orig=dialog.get_filename()
    309312                                dialog.destroy()
     
    346349                                                        self.manage_message(True,13)   
    347350                                        except:
     351                                                self.recovery=True
     352                                                '''
    348353                                                self.backup=False
    349354                                                self.orig=self.import_result['data']+".zip"
     
    352357                                                self.waiting_label.set_text(self.get_msg(28))
    353358                                                GLib.timeout_add(100,self.pulsate_recovery_bells)
    354                                                 return False   
     359                                                return False
     360                                                '''     
    355361                                else:
    356362                                        self.manage_message(True,self.read_conf['code'])       
     
    359365
    360366                        else:
     367                                #self.manage_message(True,self.import_result['code'])   
     368                                self.cont=0
     369                                self.recovery=True
     370                                #return False
     371
     372                        if self.recovery:
     373                                self.backup=False
     374                                self.recovery=False
     375                                self.orig=self.import_result['data']+".zip"
    361376                                self.manage_message(True,self.import_result['code'])   
    362                                 self.cont=0
    363                                 return False
     377                                self.init_threads()
     378                                self.recovery_bells_t.start()
     379                                self.waiting_window.show()
     380                                self.waiting_label.set_text(self.get_msg(28))
     381                                GLib.timeout_add(100,self.pulsate_recovery_bells)
     382                                return False           
    364383
    365384        #def pulsate_import_bells
     
    487506                if show:
    488507                        self.cancel_button.show()
     508                        self.cancel_button.set_sensitive(True)
    489509                        self.save_button.show()
    490                         self.msg_label.hide()
     510                        self.save_button.set_sensitive(True)
     511                        self.msg_label.set_text("")
    491512                        self.enable_holiday_switch.hide()
    492513                        self.enable_holiday_label.hide()
     
    494515                        self.cancel_button.hide()
    495516                        self.save_button.hide()
    496                         self.msg_label.hide()
     517                        self.msg_label.set_text("")
    497518                        self.enable_holiday_switch.show()
    498519                        self.enable_holiday_label.show()
     
    502523
    503524                       
    504         def manage_message(self,error,code):
     525        def manage_message(self,error,code,data=None):
    505526
    506527                msg=self.get_msg(code)
    507                
     528                if data!=None:
     529                        msg=msg+data
     530
    508531                if error:
    509532                        self.msg_label.set_name("MSG_ERROR_LABEL")
     
    512535
    513536                self.msg_label.set_text(msg)
    514                 self.msg_label.show()
     537                #self.msg_label.show()
    515538
    516539        #def manage_message             
     
    593616                elif code==37:
    594617                        msg_text=_("Unabled to load bell list due to problems with cron sync") 
    595 
     618                elif code==38:
     619                        msg_text=_("The specified folder does not contain playable files")     
     620                elif code==39:
     621                        msg_text=_("You must indicate a file")
     622                elif code==40:
     623                        msg_text=_("The specified list has not valid urls. Errors in lines: ") 
     624                elif code==41:
     625                        msg_text=_("Unabled to validated the data")                             
     626                elif code==42:
     627                        msg_text=_("Unabled to validated the data. Internet connection not detected")
     628                elif code==43:
     629                        msg_text=_("The specified list is not valid")           
    596630                       
    597631                return msg_text
     
    602636
    603637                self.core.holidayBox.start_api_connect()
    604                 self.msg_label.hide()
     638                self.msg_label.set_text("")
    605639                self.manage_menubar(False)
    606640                self.enable_holiday_switch.hide()
     
    672706        #def enable_holiday_control
    673707
    674 
     708        def help_clicked(self,widget):
     709
     710                lang=os.environ["LANG"]
     711
     712                if 'ca_ES' in lang:
     713                        cmd='xdg-open http://wiki.lliurex.net/tiki-index.php?page=Bell+Scheduler_va'
     714                else:
     715                        cmd='xdg-open http://wiki.lliurex.net/tiki-index.php?page=Bell%2BScheduler'
     716
     717                os.system(cmd)
     718       
     719        #def help_clicked
     720                               
    675721        def quit(self,widget):
    676722
  • bell-scheduler/trunk/fuentes/bell-scheduler/python3-bellscheduler/bellmanager.py

    r7252 r7743  
    11#!/usr/bin/env python3
    22
     3import gi
     4gi.require_version('Gtk', '3.0')
     5from gi.repository import Gtk, GObject, GLib
    36import os
    47import json
     
    1114import shutil
    1215import subprocess
     16import threading
     17import glob
     18import random
     19import urllib.request
    1320
    1421
     
    6875        #def save_conf         
    6976
    70         def check_data(self,name,files):
     77        def check_data(self,data):
     78
     79                '''
     80                Result code:
     81                        -1: Missing bell name
     82                        -3: Missing sound file
     83                        -5: Missing image file
     84                        -6: Missing url
     85                        -7: Missing sound directory
     86                        -39: Missing list url
     87                        -42: Failed internet connection
     88
     89                '''     
    7190               
    7291                check_image=None
    7392                check_sound=None
    74                 if name=="":
    75                         return {"result":False,"code":1}
    76                        
    77 
    78                 if len(files)>0:
    79                                                                        
    80                         if files["image"]!="":
    81                                 if files["image"]!=None:
    82                                         check_image=self.check_mimetypes(files["image"],"image")
     93
     94                if data["name"]=="":
     95                        return {"result":False,"code":1,"data":""}
     96                       
     97
     98                                               
     99                if data["image"]["option"]=="custom":                                           
     100                        if data["image"]["file"]!=None:
     101                                check_image=self.check_mimetypes(data["image"]["file"],"image")
     102                               
     103                        else:
     104                                return {"result":False,"code":5,"data":""}
     105               
     106                if check_image==None:
     107                        if data["sound"]["option"]=="file":
     108                                if data["sound"]["file"]!=None:
     109                                        check_sound=self.check_mimetypes(data["sound"]["file"],"audio")
    83110                                       
     111                                        if check_sound==None:
     112                                                return self.check_audiofile(data["sound"]["file"],"file")
     113                                        else:
     114                                                return check_sound
    84115                                else:
    85                                         return {"result":False,"code":5}
    86                        
    87                         if check_image==None:
    88                                 if files["sound"]!="":
    89                                         if files["sound"]!=None:
    90                                                 check_sound=self.check_mimetypes(files["sound"],"audio")
    91                                                 if check_sound==None:
    92                                                         return self.check_audiofile(files["sound"],"file")
    93                                                 else:
    94                                                         return check_sound
     116                                        return {"result":False,"code":3,"data":""}
     117
     118                        elif data["sound"]["option"]=="directory":
     119                                if data["sound"]["file"]==None:
     120                                        return {"result":False,"code":7,"data":""}
     121                                else:
     122                                        self.correct_files=0
     123                                        return self.check_directory(data["sound"]["file"])     
     124
     125                        elif data["sound"]["option"]=="url":                   
     126                                if data["sound"]["file"]=="":
     127                                        return {"result":False,"code":6,"data":""}
     128                                else:
     129                                        check_connection=self.check_connection()
     130                                        if check_connection:
     131                                                return self.check_audiofile(data["sound"]["file"],"url")
    95132                                        else:
    96                                                 return {"result":False,"code":3}
     133                                                return {"result":False,"code":42,"data":""}     
     134
     135                        elif data["sound"]["option"]=="listurl":                               
     136                                if data["sound"]["file"]!=None:
     137                                        check_connection=self.check_connection()
     138                                        if check_connection:
     139                                                return self.check_list(data["sound"]["file"])
     140                                        else:
     141                                                return {"result":False,"code":42,"data":""}     
     142                                else:           
     143                                        return {"result":False,"code":39,"data":""}
     144                       
     145                                               
     146                else:
     147                        return check_image                     
    97148                               
    98                                 if files["url"]!=None:
    99                                         if files["url"]=="":
    100                                                 return {"result":False,"code":6}
    101                                         else:
    102                                                 return self.check_audiofile(files["url"],"url")
    103 
    104                                 if files["directory"]!="":
    105                                         if files["directory"]==None:
    106                                                 return {"result":False,"code":7}
    107                                         else:
    108                                                 return {"result":True,"code":0}         
    109                         else:
    110                                 return check_image                     
     149       
     150        #def check_data
     151       
     152        def check_mimetypes(self,file,check):
     153
    111154                '''
    112                 if duration==0:
    113                         return {"result":False,"code":8}                       
    114                 '''
    115                 return {"result":True,"code":0}                 
    116        
    117         #def check_data
    118        
    119         def check_mimetypes(self,file,check):
     155                Result code:
     156                        -2: Invalid sound file
     157                        -4: Invalid image file
     158               
     159                '''     
    120160       
    121161                mime = MimeTypes()
    122                 mime_type = mime.guess_type(file)
     162                file_mime_type= mime.guess_type(file)
     163                error=False
    123164               
    124165                if check=="audio":
    125                         sound_mime=mime.guess_type(file)
    126                         if not 'audio' in sound_mime[0] and not 'video' in sound_mime[0]:
    127                                 return {"result":False,"code":2}
    128                                
    129                 else:
    130                         image_mime=mime.guess_type(file)
    131                         if not 'image' in image_mime[0]:
    132                                 return {"result":False,"code":4}
     166                        if file_mime_type[0]!=None:
     167                                if not 'audio' in file_mime_type[0] and not 'video' in file_mime_type[0]:
     168                                        error=True
     169                        else:
     170                                error=True
     171                else:
     172                        if file_mime_type[0]!=None:
     173                                if not 'image' in file_mime_type[0]:
     174                                        error=True
     175                        else:
     176                                error=True
     177
     178                if error:
     179                        if check=="audio":
     180                                return {"result":False,"code":2,"data":""}
     181                        else:
     182                                return {"result":False,"code":4,"data":""}                             
    133183               
    134184        #def check_mimetypes                   
    135185                               
    136186        def check_audiofile(self,file,type):
     187
     188                '''
     189                Result code:
     190                        -0: All correct
     191                        -8: Sound file or ulr not valid
     192               
     193                '''     
    137194               
    138195                params=' -show_entries stream=codec_type,duration -of compact=p=0:nk=1'
     
    148205               
    149206                if len(poutput)==0:
    150                         return {"result":False, "code":8}       
    151                 else:
    152                         return {"result":True,"code":0}
    153        
    154        
    155         #def check_audiofile           
     207                        return {"result":False,"code":8,"data":""}     
     208                else:
     209                        return {"result":True,"code":0,"data":""}
     210       
     211       
     212        #def check_audiofile   
     213
     214        def check_directory(self,directory):
     215
     216                '''
     217                Result code:
     218                        -0: All correct
     219                        -38: Not correct files in directory
     220               
     221                '''     
     222
     223               
     224                path=directory+"/*"
     225                content_directory=glob.glob(path)
     226                for item in content_directory:
     227                        if os.path.isfile(item):
     228                                check_file=self.check_mimetypes(item,"audio")
     229                                if check_file==None:
     230                                        check_run=self.check_audiofile(item,'file')
     231                                        if check_run["result"]:
     232                                                self.correct_files+=1
     233                        else:
     234                                if os.path.isdir(item):
     235                                        self.check_directory(item)                     
     236               
     237                if self.correct_files>0:
     238                        return {"result":True,"code":0,"data":""}
     239                else:
     240                        return {"result":False,"code":38,"data":""}
     241
     242        #def check_directory           
     243
     244        def check_list(self,listurl):
     245
     246                '''
     247                Result code:
     248                        -0: All correct
     249                        -40: Url list with errors
     250                        -41: time out validation
     251                        -43: File not valid
     252               
     253                '''     
     254                result=True
     255                data=""
     256                code=0
     257                self.url_invalid=[]
     258                self.error_lines=[]
     259                self.file=listurl
     260                self.sync_threads={}
     261                self.read_list()
     262                self.max_timeout=300
     263                self.current_timeout=0
     264
     265                while self.worker():
     266                        import time
     267                        time.sleep(1)
     268
     269                if self.worker_ret==0: 
     270                        if len(self.sync_threads)>0:
     271                                if len(self.url_invalid)>0 or len(self.error_lines):
     272                                        data=self.order_error_lines()
     273                                        result=False
     274                                        code=40
     275                        else:
     276                                result=False
     277                                code=43
     278                                                       
     279                else:
     280                        result=False
     281                        code=41
     282
     283                return {"result":result,"code":code,"data":data}                                       
     284
     285        #def check_list         
     286       
     287        def worker(self):
     288
     289                self.current_timeout+=1
     290                self.worker_ret=1
     291                if self.current_timeout > self.max_timeout:
     292                        self.worker_ret=-1
     293                        return False
     294
     295                for i in range(len(self.threads_alive)-1,-1,-1):
     296                        if not self.threads_alive[i].is_alive():
     297                                self.threads_alive.pop(i)
     298
     299                if len(self.threads_alive)>0:
     300                        return True
     301
     302                self.worker_ret=0
     303                return False
     304
     305        #def worker
     306
     307
     308        def generate_url_threads(self,item,line_num):
     309               
     310                id=int(random.random()*1000)           
     311                t=threading.Thread(target=self.check_url,args=(id,item,line_num))
     312                t.daemon=True
     313                t.start()
     314                self.sync_threads[id]={}
     315                self.sync_threads[id]["thread"]=t
     316                return t       
     317
     318        #def generate_url_threads       
     319
     320        def read_list(self):
     321
     322                try:
     323                        content=open(self.file,'r')
     324                        self.threads_alive=[]
     325                        line_num=1
     326                        if os.stat(self.file).st_size>0:
     327                                for line in content.readlines():
     328                                        if line!="\n":
     329                                                if line.startswith("http:") or line.startswith("https:"):
     330                                                        t=self.generate_url_threads(line,line_num)
     331                                                        self.threads_alive.append(t)
     332                                                else:
     333                                                        self.error_lines.append(line_num)       
     334                                        line_num+=1
     335                except:
     336                        pass                   
     337               
     338        #def read_list         
     339
     340        def     check_url(self,id,line,line_num):
     341
     342                params=' -show_entries stream=codec_type,duration -of compact=p=0:nk=1'
     343                cmd='ffprobe -i $(youtube-dl -g "'+line+'" |sed -n 2p) '+params
     344                p=subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE)
     345                poutput=p.communicate()[0]
     346                if len(poutput)==0:
     347                        self.url_invalid.append(line_num)
     348       
     349        #def check_url 
     350
     351        def order_error_lines(self):
     352
     353                errors=""
     354               
     355                error_lines=sorted(self.url_invalid+self.error_lines)   
     356                for item in  error_lines:
     357                        errors=errors+","+str(item)
     358
     359                return errors[1:]
     360
     361        #def get_lines_error   
     362
     363        def check_connection(self):
     364       
     365                try:
     366                        res=urllib.request.urlopen("http://lliurex.net")
     367                        return True
     368                       
     369                except:
     370                        return False   
     371
     372        #def check_connection           
    156373                       
    157374        def get_order_bell(self,info=None):
     
    246463        #def enable_holiday     
    247464
     465
     466                       
     467                                                       
     468
    248469#class BellManager             
  • bell-scheduler/trunk/fuentes/bell-scheduler/python3-bellscheduler/rsrc/bell-scheduler.ui

    r7487 r7743  
    395395                            </child>
    396396                            <child>
    397                               <object class="GtkLabel" id="duration_label">
    398                                 <property name="visible">True</property>
    399                                 <property name="can_focus">False</property>
    400                                 <property name="margin_top">7</property>
    401                                 <property name="label" translatable="yes">Max. duration (in seconds)</property>
    402                                 <property name="xalign">0</property>
    403                               </object>
    404                               <packing>
    405                                 <property name="left_attach">0</property>
    406                                 <property name="top_attach">4</property>
    407                               </packing>
    408                             </child>
    409                             <child>
    410                               <object class="GtkSpinButton" id="duration_entry">
    411                                 <property name="visible">True</property>
    412                                 <property name="can_focus">True</property>
    413                                 <property name="halign">end</property>
    414                                 <property name="margin_top">7</property>
    415                                 <property name="adjustment">adjustment3</property>
    416                                 <property name="wrap">True</property>
    417                                 <property name="value">0.01</property>
    418                               </object>
    419                               <packing>
    420                                 <property name="left_attach">2</property>
    421                                 <property name="top_attach">4</property>
    422                               </packing>
    423                             </child>
    424                             <child>
    425397                              <object class="GtkRadioButton" id="file_radiobutton">
    426398                                <property name="label" translatable="yes">Sound file</property>
     
    453425                            </child>
    454426                            <child>
    455                               <object class="GtkRadioButton" id="random_radiobutton">
     427                              <object class="GtkRadioButton" id="directory_radiobutton">
    456428                                <property name="label" translatable="yes">Random from directory</property>
    457429                                <property name="use_action_appearance">False</property>
     
    483455                                <property name="top_attach">2</property>
    484456                              </packing>
     457                            </child>
     458                            <child>
     459                              <object class="GtkLabel" id="duration_label">
     460                                <property name="visible">True</property>
     461                                <property name="can_focus">False</property>
     462                                <property name="margin_top">7</property>
     463                                <property name="label" translatable="yes">Max. duration (in seconds)</property>
     464                                <property name="xalign">0</property>
     465                              </object>
     466                              <packing>
     467                                <property name="left_attach">0</property>
     468                                <property name="top_attach">5</property>
     469                              </packing>
     470                            </child>
     471                            <child>
     472                              <object class="GtkSpinButton" id="duration_entry">
     473                                <property name="visible">True</property>
     474                                <property name="can_focus">True</property>
     475                                <property name="halign">end</property>
     476                                <property name="margin_top">7</property>
     477                                <property name="adjustment">adjustment3</property>
     478                                <property name="wrap">True</property>
     479                                <property name="value">0.01</property>
     480                              </object>
     481                              <packing>
     482                                <property name="left_attach">2</property>
     483                                <property name="top_attach">5</property>
     484                              </packing>
     485                            </child>
     486                            <child>
     487                              <object class="GtkRadioButton" id="listurl_radiobutton">
     488                                <property name="label" translatable="yes">Random from url list</property>
     489                                <property name="use_action_appearance">False</property>
     490                                <property name="visible">True</property>
     491                                <property name="can_focus">True</property>
     492                                <property name="receives_default">False</property>
     493                                <property name="margin_top">5</property>
     494                                <property name="xalign">0</property>
     495                                <property name="draw_indicator">True</property>
     496                                <property name="group">file_radiobutton</property>
     497                              </object>
     498                              <packing>
     499                                <property name="left_attach">1</property>
     500                                <property name="top_attach">4</property>
     501                              </packing>
     502                            </child>
     503                            <child>
     504                              <object class="GtkFileChooserButton" id="listurl_filechosser">
     505                                <property name="visible">True</property>
     506                                <property name="can_focus">False</property>
     507                                <property name="margin_top">5</property>
     508                                <property name="margin_bottom">10</property>
     509                                <property name="create_folders">False</property>
     510                              </object>
     511                              <packing>
     512                                <property name="left_attach">2</property>
     513                                <property name="top_attach">4</property>
     514                              </packing>
     515                            </child>
     516                            <child>
     517                              <placeholder/>
    485518                            </child>
    486519                            <child>
     
    682715                <property name="can_focus">False</property>
    683716                <property name="tooltip_text" translatable="yes">Manage holiday</property>
     717                <property name="margin_right">10</property>
    684718                <property name="use_underline">True</property>
    685719                <property name="stock_id">gtk-index</property>
     720              </object>
     721              <packing>
     722                <property name="expand">False</property>
     723                <property name="homogeneous">True</property>
     724              </packing>
     725            </child>
     726            <child>
     727              <object class="GtkToolButton" id="help_button">
     728                <property name="visible">True</property>
     729                <property name="can_focus">False</property>
     730                <property name="tooltip_text" translatable="yes">Help</property>
     731                <property name="label" translatable="yes">toolbutton1</property>
     732                <property name="use_underline">True</property>
     733                <property name="stock_id">gtk-help</property>
    686734              </object>
    687735              <packing>
  • bell-scheduler/trunk/fuentes/debian/n4d-bellscheduler.postinst

    r7647 r7743  
    1010                echo "Coping script to update bell file to use indicator"
    1111                cp /usr/share/bell-scheduler/one-shots/update-indicator-token.sh /etc/n4d/one-shot/
     12                deb-systemd-invoke restart n4d || true
     13        fi
     14        if dpkg --compare-versions "$2" lt 0.3.5; then
     15                echo "Coping script to update bell config file"
     16                cp /usr/share/bell-scheduler/one-shots/update-bell-list.sh /etc/n4d/one-shot/
    1217                deb-systemd-invoke restart n4d || true
    1318        fi
  • bell-scheduler/trunk/fuentes/n4d-bellscheduler.install/etc/n4d/conf.d/BellSchedulerManager

    r7527 r7743  
    1313update_indicator_token=adm,admins,teachers
    1414stop_bell=*,anonymous
     15update_config_file=adm,admins,teachers
  • bell-scheduler/trunk/fuentes/n4d-bellscheduler.install/usr/bin/randomaudiofile

    r7253 r7743  
    33TEMPATH=$(mktemp)
    44TEMPATH2=$(mktemp)
    5 find "$MUSICPATH" -type f > $TEMPATH
    6 while read musicfile ;  do
    7         mimetype=$(file -i "$musicfile" | awk -F ':' '{ if ( $2 ~ /audio/ || $2 ~ /video/ ) print "audio" ; else if ($2 ~ /octet-stream/ ) print "check" }')
    8         if [ "$mimetype" = "audio" ]; then
    9                 echo $musicfile >> $TEMPATH2
    10         elif [ "$mimetype" = "check" ]; then
    11                 mimetype=$(mimetype $musicfile | awk -F ':' '{if ( $2 ~ /audio/ || $2 ~ /video/) print "audio"}')
    12                 if [ $mimetype = "audio" ]; then
    13                         echo $musicfile >> $TEMPATH2
     5
     6if [ -d $MUSICPATH ];then
     7        TYPE="directory"
     8elif [ -f $MUSICPATH ];then
     9        TYPE="list"
     10fi
     11
     12case $TYPE in
     13
     14        directory)     
     15                #statements     
     16                find "$MUSICPATH" -type f > $TEMPATH
     17                while read musicfile ;  do
     18                        mimetype=$(file -i "$musicfile" | awk -F ':' '{ if ( $2 ~ /audio/ || $2 ~ /video/ ) print "audio" ; else if ($2 ~ /octet-stream/ ) print "check" }')
     19                        if [ "$mimetype" = "audio" ]; then
     20                                echo $musicfile >> $TEMPATH2
     21                        elif [ "$mimetype" = "check" ]; then
     22                                mimetype=$(mimetype $musicfile | awk -F ':' '{if ( $2 ~ /audio/ || $2 ~ /video/) print "audio"}')
     23                                if [ $mimetype = "audio" ]; then
     24                                        echo $musicfile >> $TEMPATH2
     25                                fi
     26                        fi
     27                       
     28                done < $TEMPATH
     29                echo $(cat $TEMPATH2 | shuf -n 1)
     30                rm $TEMPATH $TEMPATH2
     31        ;;
     32
     33        list)   
     34                if [ -f $MUSICPATH ]; then
     35                        echo $(grep . $MUSICPATH | shuf -n 1 )  | sed -e 's,%,\%,g'
     36
    1437                fi
    15         fi
     38        ;;
     39
     40        *)
     41
     42        ;;     
    1643       
    17 done < $TEMPATH
    18 echo $(cat $TEMPATH2 | shuf -n 1)
    19 rm $TEMPATH $TEMPATH2
     44esac                   
  • bell-scheduler/trunk/fuentes/n4d-bellscheduler.install/usr/share/n4d/python-plugins/BellSchedulerManager.py

    r7647 r7743  
    6868
    6969               
    70                 return {"status":True,"msg":"Configuration file created successfuly"}
     70                return {"status":True,"msg":"Configuration file created successfuly","code":"","data":""}
    7171
    7272        #def create_conf               
     
    7575        def read_conf(self):
    7676               
     77                '''
     78                Result code:
     79                        -25: Error reading configuration file
     80                        -0: All correct
     81
     82                '''     
     83
    7784                self._create_dirs()     
    7885               
     
    9299                f.close()       
    93100
    94                 return {"status":True,"msg":"Configuration file readed successfuly","code":26,"data":self.bells_config}
     101                return {"status":True,"msg":"Configuration file readed successfuly","code":0,"data":self.bells_config}
    95102
    96103        #def read_conf 
     
    120127       
    121128        def sync_with_cron(self):
     129
     130                '''
     131                Result code:
     132                        -37: Problems with cron sync
     133               
     134                '''     
    122135       
    123136                bell_tasks=self.read_conf()["data"]
     
    147160                                        result=self._delete_from_cron(item)
    148161                                        if not result["status"]:
    149                                                 return {"status":False,"msg":"Unable to clear alarm from cron file","code":37}
     162                                                return {"status":False,"msg":"Unable to clear alarm from cron file","code":37,"data":""}
    150163                else:
    151164                        for item in bell_tasks:
     
    158171                        self._write_conf(bell_tasks,"BellList")
    159172
    160                 return {"status":True,"msg":"Sync with cron sucessfully","data":bell_tasks}     
     173                return {"status":True,"msg":"Sync with cron sucessfully","code":"","data":bell_tasks}   
    161174                                       
    162175
     
    184197
    185198        def save_changes(self,info,last_change,action):
     199
     200                '''
     201                Result code:
     202                        -19: Problems to edit bell
     203                        -20: Problems to create bell
     204                        -21: Problems to delete bell
     205                        -22: Problems to activate bell
     206                        -23: Probles to deactivate bell
     207               
     208                '''
    186209               
    187210                turn_on=False
     
    202225                else:
    203226                        if action=="edit":
    204                                 return {"status":False,"action":action,"msg":result['data'],"code":19
     227                                return {"status":False,"action":action,"msg":result['data'],"code":19,"data":""}       
    205228                        elif action=="add":
    206                                 return {"status":False,"action":action,"msg":result['data'],"code":20}
     229                                return {"status":False,"action":action,"msg":result['data'],"code":20,"data":""}
    207230                        elif action=="remove":
    208                                 return {"status":False,"action":action,"msg":result['data'],"code":21
     231                                return {"status":False,"action":action,"msg":result['data'],"code":21,"data":""}       
    209232                        elif action=="active": 
    210233                                if turn_on:
    211                                         return {"status":False,"action":action,"msg":result['data'],"code":22}
     234                                        return {"status":False,"action":action,"msg":result['data'],"code":22,"data":""}
    212235                                else:
    213                                         return {"status":False,"action":action,"msg":result['data'],"code":23}
     236                                        return {"status":False,"action":action,"msg":result['data'],"code":23,"data":""}
    214237               
    215238        #def save_changes                               
     
    299322                        cmd=self.cmd_create_token+write_token_command+"ffplay -nodisp -autoexit "
    300323
    301                 if sound_option !="url":
    302                         if sound_option =="file":
    303                                 cmd=cmd+' "'+ sound_path +'" '+fade_effects+self.cmd_remove_token
    304                         else:
    305                                 #random_file="$(find"+ " '"+sound_path+"' -type f -print0 | xargs -0 file -i | awk -F ':' '{ if ($2 ~ /audio/ || $2 ~ /video/ ) print $1 }'| shuf -n 1)"
    306                                 random_file="$(randomaudiofile" + " '"+sound_path+"')"
     324                if sound_option=="file":
     325                        cmd=cmd+' "'+ sound_path +'" '+fade_effects+self.cmd_remove_token
     326                elif sound_option=="url":
     327                        f=sound_path.replace("%","\%")
     328                        cmd=cmd+ ' $(youtube-dl -g "'+sound_path+'" | sed -n 2p) '+fade_effects+self.cmd_remove_token   
     329                else:
     330                        random_file="$(randomaudiofile" + " '"+sound_path+"')"
     331                        if sound_option=="directory":
    307332                                cmd=cmd+' "'+ random_file + '" '+fade_effects+self.cmd_remove_token
    308                                 #cmd=cmd+" $(find"+ " '"+sound_path+"' -type f | shuf -n 1) "+fade_effects             
    309                 else:
    310                         sound_path=sound_path.replace("%","\%")
    311                         cmd=cmd+ ' $(youtube-dl -g "'+sound_path+'" | sed -n 2p) '+fade_effects+self.cmd_remove_token
     333                        elif sound_option=="listurl":
     334                                cmd=cmd+ ' $(youtube-dl -g "'+random_file+'" | sed -n 2p) '+fade_effects+self.cmd_remove_token
    312335                       
    313336                info_to_cron["BellScheduler"][key]["cmd"]=cmd
     
    325348        def copy_media_files(self,image,sound):
    326349
     350
     351                '''
     352                Result code:
     353                        -24: Problems to copy sounds/image files
     354               
     355                '''
    327356
    328357                self._create_dirs()
     
    345374                                        shutil.copy2(sound,sound_dest)
    346375
    347                         result={"status":True,"msg":"Files copied successfully"}
     376                        result={"status":True,"msg":"Files copied successfully","code":"","data":""}
    348377                except Exception as e:
    349                                 result={"status":False,"msg":str(e),"code":24}         
     378                                result={"status":False,"msg":str(e),"code":24,"data":""}               
    350379
    351380                return result
     
    354383
    355384        def export_bells_conf(self,dest_file,user,arg=None):
     385
     386                '''
     387                Result code:
     388                        -11: File saved ok
     389                        -12: Unable to save file
     390                '''
    356391
    357392                tmp_export=tempfile.mkdtemp("_bell_export")
     
    368403                                shutil.copytree(self.media_files_folder,os.path.join(tmp_export,"media"))
    369404                       
     405                        dest_file=os.path.splitext(dest_file)[0]
    370406                        shutil.make_archive(dest_file, 'zip', tmp_export)
    371407                        if arg!=True:
     
    374410                        cmd='chown -R '+user+':'+user +" " + dest_file+'.zip'
    375411                        os.system(cmd) 
    376                         result={"status":True,"msg":"Bells exported successfullly","code":11}
     412                        result={"status":True,"msg":"Bells exported successfullly","code":11,"data":""}
    377413                                               
    378414                except Exception as e:
    379                         result={"status":False,"msg":str(e),"code":12}         
     415                        result={"status":False,"msg":str(e),"code":12,"data":""}               
    380416
    381417                return result   
     
    385421        def import_bells_conf(self,orig_file,user,backup):
    386422
    387                 self._create_dirs()
     423                '''
     424                Result code:
     425                        -9: Errors in import file
     426                        -10: Import ok
     427               
     428                '''
     429
     430                #self._create_dirs()
     431
    388432                backup_file=["",""]
    389433                unzip_tmp=tempfile.mkdtemp("_import_bells")
     
    401445                                tmp_zip.close   
    402446
    403                                 config_file=os.path.join(unzip_tmp,os.path.basename(self.config_file)) 
    404                                 if os.path.exists(config_file):
    405                                         try:
    406                                                 f=open(config_file)
    407                                                 read=json.load(f)
    408                                                 shutil.copy2(config_file,self.config_dir)
    409                                                 f.close()
    410                                         except Exception as e:
    411                                                 result={"status":False,"msg":str(e),"code":9,"data":backup_file[1]}     
    412                                                 return result           
    413                                                        
    414                                 cron_file=os.path.join(unzip_tmp,os.path.basename(self.cron_file))
    415                                 if os.path.exists(cron_file):
    416                                         try:
    417                                                 f=open(cron_file)
    418                                                 read=json.load(f)
    419                                                 shutil.copy2(cron_file,self.cron_dir)
    420                                                 f.close()
    421                                                 #self.n4d.process_tasks(self.n4dkey,'SchedulerClient')
    422                                         except Exception as e:
    423                                                 result={"status":False,"msg":str(e),"code":9,"data":backup_file[1]}     
    424                                                 return result   
     447                                try:
     448                                        config_file=os.path.join(unzip_tmp,os.path.basename(self.config_file)) 
     449                                        f_config=open(config_file)
     450                                        read=json.load(f_config)
     451                                        self.update_config_file(config_file)
     452                                        shutil.copy2(config_file,self.config_dir)
     453                                        f_config.close()
     454                                        cron_file=os.path.join(unzip_tmp,os.path.basename(self.cron_file))
     455                                        f_cron=open(cron_file)
     456                                        read=json.load(f_cron)
     457                                        shutil.copy2(cron_file,self.cron_dir)
     458                                        f_cron.close()
     459                                       
     460                                except Exception as e:
     461                                        result={"status":False,"msg":str(e),"code":9,"data":backup_file[1]}     
     462                                        return result           
    425463
    426464                                holiday_token=os.path.join(unzip_tmp,os.path.basename(self.holiday_token))     
     465
    427466                                if os.path.exists(holiday_token):
    428467                                        action="enable"
     
    435474                                        if os.path.exists(self.images_folder):
    436475                                                shutil.rmtree(self.images_folder)
    437                                                 shutil.copytree(os.path.join(unzip_tmp,"media/images"),self.images_folder)
     476                                        shutil.copytree(os.path.join(unzip_tmp,"media/images"),self.images_folder)
    438477
    439478                                if os.path.exists(os.path.join(unzip_tmp,"media/sounds")):
    440479                                        if os.path.exists(self.sounds_folder):
    441480                                                shutil.rmtree(self.sounds_folder)
    442                                                 shutil.copytree(os.path.join(unzip_tmp,"media/sounds"),self.sounds_folder)
     481                                        shutil.copytree(os.path.join(unzip_tmp,"media/sounds"),self.sounds_folder)
    443482               
    444483                                update_holiday=self.enable_holiday_control(action)     
     
    449488                                                result={"status":True,"msg":"Bells imported successfullly","code":10,"data":backup_file[1]}
    450489                                        else:
    451                                                 result={"status":False,"msg":update_indicator["msg"],"code":9
     490                                                result={"status":False,"msg":update_indicator["msg"],"code":9,"data":backup_file[1]}   
    452491                                else:
    453                                         result={"status":False,"msg":update_holiday["msg"],"code":9}                           
     492                                        result={"status":False,"msg":update_holiday["msg"],"code":9,"data":backup_file[1]}                             
    454493                except Exception as e:
    455494                        result={"status":False,"msg":str(e),"code":9,"data":backup_file[1]}     
     
    461500
    462501        def enable_holiday_control(self,action):
     502
     503                '''
     504                Result code:
     505                        -34: Holiday control deactivated ok
     506                        -35: Holiday control activated ok
     507               
     508                '''
    463509
    464510                result=self._update_holiday_control(action)
     
    467513                                if os.path.exists(self.holiday_token):
    468514                                        os.remove(self.holiday_token)   
    469                                         result={"status":True,"msg":"Holiday token removed","code":34}
     515                                        result={"status":True,"msg":"Holiday token removed","code":34,"data":""}
    470516                        else:
    471517                                if not os.path.exists(self.holiday_token):
     
    474520                                        f=open(self.holiday_token,'w')
    475521                                        f.close()
    476                                         result={"status":True,"msg":"Holiday token created","code":35}         
     522                                        result={"status":True,"msg":"Holiday token created","code":35,"data":""}               
    477523               
    478524                return result           
     
    482528        def _update_holiday_control(self,action):
    483529
     530                '''
     531                Result code:
     532                        -36: Changes not apply due to cron
     533                        -37: Bell list not loaded due to cron
     534               
     535                '''
    484536               
    485537                if os.path.exists(self.cron_file):
     
    488540                                tasks_cron=json.load(f)
    489541                        except Exception as e:
    490                                 result={"status":False,"msg":str(e),"code":36}
     542                                result={"status":False,"msg":str(e),"code":36,"data":""}
    491543                                return result
    492544
     
    502554                        self._write_conf(tasks_cron,"CronList")
    503555                        self.n4d.process_tasks(self.n4dkey,'SchedulerClient')
    504                         result={"status":True,"msg":"Cron file updated to use holiday manager","code":""}
    505                 else:
    506                         result={"status":True,"msg":"Cron file dosn't exists","code":37}                       
     556                        result={"status":True,"msg":"Cron file updated to use holiday manager","code":"","data":""}
     557                else:
     558                        result={"status":False,"msg":"Cron file dosn't exists","code":37,"data":""}                     
    507559
    508560                return result
     
    512564
    513565        def update_indicator_token(self):
     566
     567                '''
     568                Result code:
     569                        -37: Bell list not loaded due to cron
     570               
     571                '''
    514572
    515573                if os.path.exists(self.cron_file):
     
    520578                                f.close()
    521579                        except Exception as e:
    522                                 result={"status":False,"msg":str(e),"code":"36"}
     580                                result={"status":False,"msg":str(e),"code":36,"data":""}
    523581                                return result
    524582
     
    532590                        self._write_conf(tasks_cron,"CronList")
    533591                        self.n4d.process_tasks(self.n4dkey,'SchedulerClient')
    534                         result={"status":True,"msg":"Cron file updated to use indicator","code":""}
    535                 else:
    536                         result={"status":True,"msg":"Cron file dosn't exists","code":37}                       
     592                        result={"status":True,"msg":"Cron file updated to use indicator","code":"","data":""}
     593                else:
     594                        result={"status":False,"msg":"Cron file dosn't exists","code":37,"data":""}                     
    537595
    538596                return result
     
    542600        def stop_bell(self):
    543601               
     602                cmd_kill=""
     603                bells_pid=""
    544604                cmd='ps -ef | grep "ffplay -nodisp -autoexit" | grep -v "grep"'
    545605                p=subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
     
    562622                                                        tmp_list.append(object)
    563623                                        processed_line=tmp_list
    564                                         bell_pid=processed_line[1]
    565                                         cmd_kill='kill ' +str(bell_pid)
    566                                         os.system(cmd_kill)
    567                                                
    568                                         result={"status":True,"msg":"Alarm stoppped:"+bell_pid,"code":""}
    569                                         return result   
     624                                        pid_bell=processed_line[1]
     625                                        bells_pid=bells_pid+pid_bell+" "
     626                                        cmd_kill=cmd_kill+'kill ' +str(pid_bell)+";"
     627                        os.system(cmd_kill)
     628                        result={"status":True,"msg":"Alarm stoppped:"+bells_pid,"code":"","data":""}
     629                        return result   
    570630
    571631        #def stop_bell
    572632                       
     633
     634        def update_config_file(self,file=None):
     635
     636                if file!=None:
     637                        file=file
     638                else:
     639                        file=self.config_file
     640
     641                if os.path.exists(file):
     642                        f=open(file,'r')
     643                        filedata=f.read()
     644                        filedata=filedata.replace('"option": "random"','"option": "directory"')
     645                        f=open(file,'w')
     646                        f.write(filedata)
     647                        f.close()
     648               
     649
     650        #def update_confif_file
    573651               
    574652#def BellSchedulerManager
Note: See TracChangeset for help on using the changeset viewer.