Ignore:
Timestamp:
Feb 13, 2018, 4:52:00 PM (20 months ago)
Author:
Juanma
Message:

WIP

Location:
taskscheduler/trunk/fuentes
Files:
5 added
27 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • taskscheduler/trunk/fuentes/client-scheduler.install/usr/share/n4d/python-plugins/SchedulerClient.py

    r6763 r6811  
    88import threading
    99import time
     10from  datetime import date
    1011import xmlrpclib as xmlrpc
    1112
     
    4142        def process_tasks(self,data=None):
    4243                self._debug("Scheduling tasks")
     44                today=date.today()
    4345                prefixes={'remote':True,'local':False}
    4446                tasks={}
     
    5254                        else:
    5355                                n4d=xmlrpc.ServerProxy("https://localhost:9779")
    54                         tasks=n4d.get_tasks("","SchedulerServer",sw_remote,False)['data'].copy()
     56                        tasks=n4d.get_tasks("","SchedulerServer")['data'].copy()
     57
    5558                        #Delete files
    5659                        for f in os.listdir(self.cron_dir):
     
    6164                        for name in tasks.keys():
    6265                                for serial in tasks[name].keys():
     66                                        sw_pass=False
     67                                        if 'autoremove' in tasks[name][serial]:
     68                                                if type(tasks[name][serial]['m'])==type(int):
     69                                                        if tasks[name][serial]['m']<today.month:
     70                                                                sw_pass=True
     71                                                if sw_pass==False:
     72                                                        if type(tasks[name][serial]['d'])==type(int):
     73                                                                if tasks[name][serial]['d']<today.day:
     74                                                                        sw_pass=True
     75                                        if sw_pass:
     76                                                continue
    6377                                        self._debug("Scheduling %s"%name)
    6478                                        fname=name.replace(' ','_')
     
    7690                                                        task_data['mon'],task_data['dow'],u""+task_data['cmd']))
    7791                        cron_array.append(cron_task)
    78 #                       for task_serial,task_info in task_data.items():
    79 #                               cron_task=("%s %s %s %s %s root %s"%(task_info['m'],task_info['h'],task_info['dom'],\
    80 #                                                               task_info['mon'],task_info['dow'],task_info['cmd']))
    81 #                               cron_array.append(cron_task)
    8292                        if task_data:
    8393                                with open(fname,'w') as data:
  • taskscheduler/trunk/fuentes/python3-taskscheduler.install/usr/share/taskscheduler/taskscheduler.py

    r6763 r6811  
    5252                tasks={}
    5353                self._debug("Retrieving task list remote=%s"%sw_remote)
    54                 if self.n4dserver and sw_remote:
    55                         result=self.n4dserver.get_tasks("","SchedulerServer",True,False)
    56                         if type(result)==type({}):
    57                                 tasks=result['data'].copy()
    58                 elif sw_remote==False:
    59                         result=self.n4dclient.get_tasks("","SchedulerServer",False,False)
    60                         if type(result)==type({}):
    61                                 tasks.update(result['data'])
     54                result=self.n4dclient.get_tasks("","SchedulerServer")
     55                if type(result)==type({}):
     56                        tasks=result['data'].copy()
    6257                return tasks
    6358        #def get_scheduled_tasks
     
    8580        def get_task_command(self,i18n_cmd):
    8681                cmd=i18n_cmd
    87                 sw_found=False
    8882                self._debug("Getting cmd for %s"%i18n_cmd)
    8983                tasks=self.get_available_tasks()
     
    9185                        if task_desc in task_data.keys():
    9286                                cmd=task_data[i18n_cmd]
    93                                 sw_found=True
    9487                                break
    9588                return cmd
     
    161154        #def write_tasks
    162155
    163         def remove_task(self,task_name,task_serial,task_cmd,sw_remote):
     156        def remove_task(self,task):
    164157                status=False
    165                 self._debug("Removing task from %s server"%sw_remote)
    166                 if sw_remote=='remote':
    167                         result=self.n4dserver.remove_task(self.credentials,"SchedulerServer",sw_remote,task_name,task_serial,task_cmd)
     158                sw_remote=False
     159                self._debug("Removing task %s"%task)
     160                if task['spread']:
     161                        result=self.n4dserver.remove_task(self.credentials,"SchedulerServer",task)
    168162                else:
    169                         result=self.n4dclient.remove_task(self.credentials,"SchedulerServer",sw_remote,task_name,task_serial,task_cmd)
     163                        result=self.n4dclient.remove_task(self.credentials,"SchedulerServer",task)
    170164                if type(result)==type({}):
    171165                        status=result['status']
  • taskscheduler/trunk/fuentes/scheduler-gui.install/usr/share/taskscheduler/bin/taskScheduler.py

    r6764 r6811  
    1919from taskscheduler.taskscheduler import TaskScheduler as scheduler
    2020from taskscheduler.cronParser import cronParser
    21 from fixedDateBox import DetailBox as fixedDateTask
    22 from intervalDateBox import DetailBox as intervalDateTask
    23 from dailyDateBox import DetailBox as dailyDateTask
     21from detailDateBox import DetailBox as detailDateBox
    2422from edupals.ui.n4dgtklogin import *
    2523import signal
     
    3432GLADE_FILE=BASE_DIR+"rsrc/taskScheduler.ui"
    3533REMOVE_ICON=BASE_DIR+"rsrc/trash.svg"
     34EDIT_ICON=BASE_DIR+"rsrc/edit.svg"
     35NO_EDIT_ICON=BASE_DIR+"rsrc/no_edit.svg"
    3636LOCK_PATH="/var/run/taskScheduler.lock"
    3737WIDGET_MARGIN=6
     
    4848                self.ldm_helper='/usr/sbin/sched-ldm.sh'
    4949                self.i18n={}
    50                 self.types={'fix':fixedDateTask,'repeat':'TaskRepeat','days':fixedDateTask}
    5150                       
    5251        #def __init__           
     
    119118                self.btn_manage_tasks=builder.get_object("btn_manage_tasks")
    120119                self.btn_manage_tasks.connect("button-release-event", self._manage_tasks)
    121                 self.btn_remote_tasks=builder.get_object("btn_remote_tasks")
    122                 self.btn_local_tasks=builder.get_object("btn_local_tasks")
    123                 self.handler_remote=self.btn_remote_tasks.connect("clicked",self.view_tasks_clicked,True)
    124                 self.handler_local=self.btn_local_tasks.connect("clicked",self.view_tasks_clicked,False)
    125120                self.txt_search=builder.get_object("txt_search")
    126121                self.txt_search.connect('changed',self.match_tasks)
     122                self.nav_box=builder.get_object("nav_box")
     123                self.nav_box.set_visible(False)
     124                self.btn_fixed_sched=builder.get_object("btn_fixed_tasks")
     125                self.btn_fixed_sched.set_visible(False)
     126                self.btn_fixed_sched.set_no_show_all(True)
     127                self.btn_daily_sched=builder.get_object("btn_daily_tasks")
     128                self.btn_daily_sched.set_visible(False)
     129                self.btn_daily_sched.set_no_show_all(True)
     130                self.btn_repeat_sched=builder.get_object("btn_repetitive_tasks")
     131                self.btn_repeat_sched.set_visible(False)
     132                self.btn_repeat_sched.set_no_show_all(True)
     133                self.btn_all_sched=builder.get_object("btn_all_tasks")
     134                self.btn_all_sched.set_visible(False)
     135                self.btn_all_sched.set_no_show_all(True)
     136                self.btn_advanced_sched=Gtk.Button()
     137                px=GdkPixbuf.Pixbuf.new_from_file("/home/lliurex/Circle-icons-countdown.svg")
     138                img=Gtk.Image().new_from_pixbuf(px)
     139                self.btn_fixed_sched.set_image(img)
     140                self.btn_fixed_sched.set_image_position(Gtk.PositionType.TOP)
     141                self.btn_fixed_sched.set_label(_("Fixed task"))
     142                px=GdkPixbuf.Pixbuf.new_from_file("/home/lliurex/Circle-icons-calendar.svg")
     143                img=Gtk.Image().new_from_pixbuf(px)
     144                self.btn_daily_sched.set_image(img)
     145                self.btn_daily_sched.set_image_position(Gtk.PositionType.TOP)
     146                self.btn_daily_sched.set_label(_("Daily task"))
     147                px=GdkPixbuf.Pixbuf.new_from_file("/home/lliurex/Circle-icons-swatches.svg")
     148                img=Gtk.Image().new_from_pixbuf(px)
     149                self.btn_repeat_sched.set_image(img)
     150                self.btn_repeat_sched.set_image_position(Gtk.PositionType.TOP)
     151                self.btn_repeat_sched.set_label(_("Repeat task"))
     152                px=GdkPixbuf.Pixbuf.new_from_file("/home/lliurex/Circle-icons-genius.svg")
     153                img=Gtk.Image().new_from_pixbuf(px)
     154                self.btn_all_sched.set_image(img)
     155                self.btn_all_sched.set_image_position(Gtk.PositionType.TOP)
     156                self.btn_all_sched.set_label(_("All tasks"))
     157                #Nav bar <--
    127158                #tasks list
    128159                self._load_task_list_gui(builder)
     
    133164                image.set_from_file(REMOVE_ICON)               
    134165                self.remove_icon=image.get_pixbuf()
     166                image.set_from_file(EDIT_ICON)         
     167                self.edit_icon=image.get_pixbuf()
     168                image.set_from_file(NO_EDIT_ICON)               
     169                self.no_edit_icon=image.get_pixbuf()
    135170
    136171                self.stack.add_titled(self.tasks_box, "tasks", "Tasks")
    137172                self.stack.add_titled(self.manage_box, "manage", "Manage")
    138173                self.stack.add_titled(self.add_task_box, "add", "Add Task")
    139 #               self.stack.add_titled(self.loginBox, "login", "Login")
    140174                self.stack.add_titled(self.login, "login", "Login")
    141175                #Packing
    142176                self.main_box.pack_start(self.stack,True,False,5)
     177
    143178                self.toolbar.props.no_show_all=True
     179                self.nav_box.props.no_show_all=True
    144180                self.window.connect("destroy",self.quit)
    145181                self.window.set_resizable(False)
     
    161197                self.tasks_label=builder.get_object("tasks_label")
    162198                self.tasks_tv=builder.get_object("tasks_treeview")
    163                 self.task_details_grid=fixedDateTask(self.scheduler)
    164 #               self.task_details_grid=DetailBox.DetailBox(self.scheduler)
    165                 td_grid=self.task_details_grid.render_form(builder.get_object("task_details_grid"))
    166                 self.detailGrid=builder.get_object("task_details_grid")
    167 
    168                 self.task_details_grid.btn_apply.set_sensitive(True)
    169                 self.task_details_grid.btn_apply.connect("clicked",self.update_task)
    170                 self.task_details_grid.chk_node.connect("toggled",self._reload_grid)
    171                 self.tasks_store=Gtk.ListStore(str,str,str,GdkPixbuf.Pixbuf,str,str,str)
     199                self.tasks_store=Gtk.ListStore(str,str,str,GdkPixbuf.Pixbuf,GdkPixbuf.Pixbuf,str,str,str,str)
    172200                self.tasks_store_filter=self.tasks_store.filter_new()
    173201                self.tasks_store_filter.set_visible_func(self.filter_tasklist)
     
    180208                column.pack_start(cell,True)
    181209                column.add_attribute(cell,"markup",0)
    182                 column.add_attribute(cell,"cell_background",6)
     210                column.add_attribute(cell,"cell_background",7)
     211                column.add_attribute(cell,"foreground",8)
    183212                column.set_expand(True)
    184213                self.tasks_tv.append_column(column)
     
    188217                column.pack_start(cell,True)
    189218                column.add_attribute(cell,"markup",1)
    190                 column.add_attribute(cell,"cell_background",6)
     219                column.add_attribute(cell,"cell_background",7)
     220                column.add_attribute(cell,"foreground",8)
    191221                column.set_expand(True)
    192222                column.set_visible(False)
     
    198228                column.pack_start(cell,False)
    199229                column.add_attribute(cell,"markup",2)
    200                 column.add_attribute(cell,"cell_background",6)
     230                column.add_attribute(cell,"cell_background",7)
     231                column.add_attribute(cell,"foreground",8)
    201232                column.set_expand(True)
    202233                self.tasks_tv.append_column(column)             
    203234
     235                column=Gtk.TreeViewColumn(_("Edit"))
     236
     237                cell=Gtk.CellRendererPixbuf()
     238                column.pack_start(cell,True)
     239                column.add_attribute(cell,"pixbuf",3)
     240                column.add_attribute(cell,"cell_background",7)
     241                self.col_edit=column
     242                self.tasks_tv.append_column(column)
     243               
    204244                column=Gtk.TreeViewColumn(_("Remove"))
    205245                cell=Gtk.CellRendererPixbuf()
    206 #               cell.set_property('cell_background','red')
    207246                column.pack_start(cell,True)
    208                 column.add_attribute(cell,"pixbuf",3)
    209                 column.add_attribute(cell,"cell_background",6)
     247                column.add_attribute(cell,"pixbuf",4)
     248                column.add_attribute(cell,"cell_background",7)
    210249                self.col_remove=column
    211250                self.tasks_tv.append_column(column)
    212                
     251
    213252                column=Gtk.TreeViewColumn(_("Command"))
    214                 cell=Gtk.CellRendererText()
    215                 column.pack_start(cell,True)
    216                 column.add_attribute(cell,"markup",4)
    217                 column.set_expand(True)
    218                 column.set_visible(False)
    219                 self.tasks_tv.append_column(column)
    220                
    221                 column=Gtk.TreeViewColumn(_("Type"))
    222253                cell=Gtk.CellRendererText()
    223254                column.pack_start(cell,True)
     
    226257                column.set_visible(False)
    227258                self.tasks_tv.append_column(column)
     259               
     260                column=Gtk.TreeViewColumn(_("Type"))
     261                cell=Gtk.CellRendererText()
     262                column.pack_start(cell,True)
     263                column.add_attribute(cell,"markup",6)
     264                column.set_expand(True)
     265                column.set_visible(False)
     266                self.tasks_tv.append_column(column)
    228267
    229268                self.tasks_tv.set_search_column(2)
     
    232271                #Add tasks
    233272                self.add_task_box=builder.get_object("add_task_box")
    234                 self.add_task_grid=fixedDateTask(self.scheduler)
    235 #               self.add_task_grid=DetailBox(self.scheduler)
    236                 at_grid=self.add_task_grid.render_form(builder.get_object("add_task_grid"),False)
     273                self.add_task_grid=detailDateBox(self.scheduler)
     274                at_grid=self.add_task_grid.render_form(builder.get_object("add_task_grid"))
    237275                at_grid=builder.get_object("add_task_grid")
    238276                self.cmb_task_names=builder.get_object("cmb_task_names")
     
    240278                builder.get_object("btn_back_add").connect("clicked", self.cancel_add_clicked)
    241279                builder.get_object("btn_cancel_add").connect("clicked", self.cancel_add_clicked)
    242                 builder.get_object("btn_confirm_add").connect("clicked", self.save_task_details)
    243                 self.chk_remote=builder.get_object("swt_remote")
    244                 self.chk_local=builder.get_object("swt_local")
     280                self.btn_confirm_add=builder.get_object("btn_confirm_add")
     281                self.btn_confirm_add.connect("clicked", self.save_task_details)
    245282        #def _load_task_list_gui
    246283
     
    314351        def _signin(self,user=None,pwd=None,server=None,data=None):
    315352                self.scheduler.set_credentials(user,pwd,server)
    316                 if server=='localhost':
    317                         self.btn_local_tasks.set_active(True)
    318                         self.btn_remote_tasks.set_visible(False)
    319                         self.btn_local_tasks.set_visible(False)
    320                 else:
    321                         self.btn_remote_tasks.set_active(True)
     353                self.stack.set_visible_child_name("tasks")
     354                self.populate_tasks_tv()
    322355                self.toolbar.show()
     356                self.nav_box.show()
    323357        #def _signin
    324358
    325359        def populate_tasks_tv(self,sw_remote=False):
    326360                self._debug("Populating task list")
    327                 self.task_details_grid.btn_apply.set_sensitive(False)
    328361                self.scheduled_tasks={}
    329362                tasks=[]
     
    333366                if type(tasks)==type({}):       
    334367                        parser=cronParser()
     368                        self.i18n['cmd']={}
     369                        self.i18n['name']={}
    335370                        for task_name in tasks.keys():
    336371                                for serial in tasks[task_name].keys():
    337372                                        task=tasks[task_name][serial]
    338373                                        task['sw_remote']=''
    339                                         color='silver'
    340                                         if 'sched' in task.keys():
    341                                                 task['sched']==task['sched']
    342                                                 color='orange'
     374                                        color_palette=['goldenrod','DarkSlateGrey','Burlywood','DarkSlateGrey','DarkSlateBlue','bisque','LightSteelBlue','DarkSlateGrey']
     375                                        bg_color=color_palette[0]
     376                                        fg_color=color_palette[1]
     377                                        if 'kind' in task.keys():
     378                                                if 'fixed' in task['kind']:
     379                                                        bg_color=color_palette[2]
     380                                                        fg_color=color_palette[3]
     381                                                elif 'repeat' in task['kind']:
     382                                                        bg_color=color_palette[4]
     383                                                        fg_color=color_palette[5]
     384                                                elif 'daily' in task['kind']:
     385                                                        bg_color=color_palette[6]
     386                                                        fg_color=color_palette[7]
    343387                                        else:
    344                                                 task['sched']=''
    345 #                                       self.scheduled_tasks[task_name]=tasks[task_name][serial]
     388                                                task['kind']=''
     389                                        remote='Local task'
     390                                        if 'spread' in task.keys():
     391                                                if task['spread']==True:
     392                                                        remote="Client task"
     393                                        else:
     394                                                task['spread']=False
    346395                                        self.scheduled_tasks[task_name]=tasks[task_name]
    347 #                                       for task in tasks[task_name][serial]:
    348396                                        sw_tasks=True
    349397                                        parsed_calendar=''
     
    351399                                        task['cmd']=task['cmd'].replace(self.ldm_helper+' ','')
    352400                                        task['action']=self.scheduler.get_task_description(task['cmd'])
    353                                         self.i18n['cmd']={_(task['action']):task['action']}
    354                                         self.i18n['name']={_(task_name):task_name}
    355                                         row=self.tasks_store.append(("<span font='Roboto'><b>"+_(task['action'])+"</b></span>\n"+\
     401                                        if 'name' in task.keys():
     402                                                name=task['name']
     403                                        else:
     404                                                name=_(task['action'])
     405                                        self.i18n['cmd'].update({name:task['action']})
     406                                        self.i18n['name'].update({_(task_name):task_name})
     407                                        img=self.edit_icon
     408                                        if 'protected' in task.keys():
     409                                                if task['protected']==True:
     410                                                        img=self.no_edit_icon
     411                                        row=self.tasks_store.append(("<span font='Roboto'><b>"+name+"</b></span>\n"+\
    356412                                                                "<span font='Roboto' size='small'><i>"+\
    357413                                                                _(task_name)+"</i></span>",serial,"<span font='Roboto' size='small'>"+\
    358                                                                 parsed_calendar+"</span>",self.remove_icon,task['sw_remote'],task['sched'],color))
    359                 if sw_tasks:
    360                         self.task_details_grid.btn_apply.set_sensitive(True)
     414                                                                parsed_calendar+"</span>\n"+"<span font='Roboto' size='small'><i>"+remote+"</i></span>",img,self.remove_icon,str(task['spread']),','.join(task['kind']),bg_color,fg_color))
    361415        #def populate_tasks_tv
    362416       
     
    384438                task={}
    385439                task['data']=model[data][0].split('\n')
     440                if _("client task") in model[data][2]:
     441                        task['spread']=True
     442                else:
     443                        task['spread']=False
    386444                task['serial']=model[data][1].split('\n')[0]
    387445                cmd=task['data'][0][task['data'][0].find("<b>")+3:task['data'][0].find("</b>")]
     
    398456
    399457                task['serial']=model[data][1]
    400                 if self.btn_remote_tasks.get_active():
    401                         task['type']='remote'
    402                         task['sw_remote']=True
    403                 else:
    404                         task['type']='local'
    405                         task['sw_remote']=False
    406458                return(task)
    407459
    408         def _click_on_delete(self,event):
    409                 sw_show=True
     460        def _click_on_list(self,event):
     461                action=''
    410462                try:
    411463                        row=self.tasks_tv.get_path_at_pos(int(event.x),int(event.y))
     
    414466                if row:
    415467                        if row[1]==self.col_remove:
    416                                 sw_show=False
    417                 return sw_show
     468                                action='remove'
     469                        elif row[1]==self.col_edit:
     470                                action='edit'
     471                self._debug(action)
     472                return action
    418473
    419474        def task_clicked(self,treeview,event=None):
    420475                self._debug("task clicked %s"%event)
    421                 if self.task_details_grid:
    422                         self.task_details_grid.clear_screen()
    423476                selection=self.tasks_tv.get_selection()
    424477                model,data=selection.get_selected()
     
    426479                        return
    427480                task={}
    428                 sw_show=True
     481                action=''
    429482                if event!=None:
    430                         sw_show=self._click_on_delete(event)
     483                        action=self._click_on_list(event)
    431484                task=self._process_model(model,data)
    432                 if sw_show:
    433                         if task['name'] in self.scheduled_tasks.keys():
    434                                 if task['serial'] in self.scheduled_tasks[task['name']].keys():
    435                                         task['data']=self.scheduled_tasks[task['name']][task['serial']]
    436                                         self._debug("Loading details of task %s of group %s remote %s"% (task['serial'],task['name'],task['sw_remote']))
    437                                         self.task_details_grid.set_task_data(task)
    438                                         self.task_details_grid.load_task_details()
    439                 else:
     485                if action=='remove':
    440486                        self.lbl_question.set_text(_("Are you sure to delete this task?"))
    441487                        for widget in self.main_box.get_children():
     
    447493                        except:
    448494                                pass
    449                         self.inf_question.connect('response',self.manage_remove_responses,model,task['name'],task['serial'],task['cmd'],task['type'],data)
     495                        self.inf_question.connect('response',self.manage_remove_responses,model,task)
     496                elif action=='edit':
     497                        if task['name'] in self.scheduled_tasks.keys():
     498                                if task['serial'] in self.scheduled_tasks[task['name']].keys():
     499                                        task['data']=self.scheduled_tasks[task['name']][task['serial']]
     500                                        self._debug("Loading details of task %s of group %s"% (task['serial'],task['name']))
     501                                        self.add_task_grid.set_task_data(task)
     502                                        self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
     503                                        self.cmb_task_names.append_text(_(task['name']))
     504                                        self.cmb_task_cmds.append_text(_(task['cmd']))
     505                                        self.cmb_task_names.set_active(0)
     506                                        self.cmb_task_cmds.set_active(0)
     507                                        self.add_task_grid.load_task_details()
     508                                        if 'protected' in task['data'].keys():
     509                                                if task['data']['protected']:
     510                                                        self.btn_confirm_add.set_sensitive(False)
     511                                        else:
     512                                                self.btn_confirm_add.set_sensitive(True)
     513                                        self.stack.set_visible_child_name("add")
    450514        #def task_clicked                       
    451515
     
    453517                task={}
    454518                name=self.cmb_task_names.get_active_text()
    455 #               task_name=self.orig_tasks[name]
    456519                task['name']=self.i18n['name'][name]
    457520                action=self.cmb_task_cmds.get_active_text()
     
    459522                tasks=self.scheduler.get_available_tasks()
    460523                task['cmd']=tasks[task['name']][i18n_action]
    461                 task['sw_remote']=False
    462 #               task_type='local'
    463                 if self.btn_remote_tasks.get_active():
    464                         task['sw_remote']=True
    465 #                       task_type='remote'
    466                 self.add_task_grid.set_task_data(task)
    467524                task=self.add_task_grid.get_task_details()
    468525
    469                 self._debug("Writing task info...")
    470                 if self.chk_remote.get_active():
    471                         status=self.scheduler.write_tasks(task,'remote')
    472                 if self.chk_local.get_active():
    473                         status=self.scheduler.write_tasks(task,'local')
     526                self._debug("Writing task info...%s"%task)
     527                status=self.scheduler.write_tasks(task,'local')
    474528                if status:
    475529                        self._show_info(_("Task saved"))
     
    482536                if widget:
    483537                        if not widget.get_active():
    484                                 if sw_remote:
    485                                         self._block_widget_state(True,widget,self.handler_remote)
    486                                 else:                                   
    487                                         self._block_widget_state(True,widget,self.handler_local)
    488538                                return True
    489539                self._debug("loading tasks (remote: %s)" % sw_remote)
    490540                if sw_remote:
    491                         self.btn_local_tasks.set_active(False)
    492                         self.btn_local_tasks.props.active=False
    493541                        self.last_task_type='remote'
    494542                else:
    495                         self.btn_remote_tasks.set_active(False)
    496                         self.btn_remote_tasks.props.active=False
    497543                        self.last_task_type='local'
    498544                self._debug("Task clicked")
    499                 self.populate_tasks_tv(sw_remote)
     545                self.populate_tasks_tv()
    500546                self.tasks_tv.set_model(self.tasks_store_filter)
    501547                self.tasks_tv.set_cursor(0)
     
    505551
    506552        def load_add_task_details(self):
    507                 if not self.btn_remote_tasks.get_visible():
    508                         self.chk_remote.set_visible(False)
    509                         self.chk_local.set_active(1)
    510                         self.chk_remote.set_active(0)
    511                         self.chk_local.set_sensitive(False)
    512                 else:
    513                         if self.btn_remote_tasks.get_active():
    514                                 self.chk_remote.set_active(1)
    515                                 self.chk_local.set_active(0)
    516                         else:
    517                                 self.chk_local.set_active(1)
    518                                 self.chk_remote.set_active(0)
    519 
    520                 self._block_widget_state(False,self.btn_remote_tasks,self.handler_remote)
    521                 self._block_widget_state(False,self.btn_local_tasks,self.handler_local)
    522553                tasks=[]
    523554                names=[]
    524 #               self.orig_tasks={}
    525555                self.cmb_task_names.remove_all()
    526556                tasks=self.scheduler.get_available_tasks()
    527557                for name in tasks.keys():
    528                         print("APPEND: %s"%name)
    529558                        if name not in names:
    530559                                names.append(name)
    531560                                self.i18n['name'].update({_(name):name})
    532 #                               self.orig_tasks[_(name)]=name
    533                                 print("PROCESS %s"%name)
    534561                                self.cmb_task_names.append_text(_(name))
    535562               
     
    544571                task_name=self.cmb_task_names.get_active_text()
    545572                if task_name:
    546 #                       orig_name=self.orig_tasks[task_name]
    547573                        orig_name=self.i18n['name'][task_name]
    548                         print(tasks)
    549574                        for action in tasks[orig_name].keys():
    550575                                if action not in actions:
     
    570595                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
    571596                self.stack.set_visible_child_name("add")
    572                 if self.btn_remote_tasks.get_active():
    573                         self.last_task_type='remote'
    574                 else:
    575                         self.last_task_type='local'
    576597                self.load_add_task_details()
    577598        #def add_task_clicked   
     
    580601                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
    581602                self.stack.set_visible_child_name("tasks")     
    582                 if self.last_task_type=='remote':
    583                         self._block_widget_state(True,self.btn_remote_tasks,self.handler_remote)
    584                 else:
    585                         self._block_widget_state(True,self.btn_local_tasks,self.handler_local)
    586603                self._debug("Cancel add clicked")
    587604                self._reload_grid()
     
    591608                cursor=self.tasks_tv.get_cursor()[0]
    592609                self._debug("CURSOR %s"%widget)
    593                 if self.btn_remote_tasks.get_active():
    594 #                       task_type='remote'
    595                         sw_remote=True
    596                 else:
    597 #                       task_type='local'
    598                         sw_remote=False
    599610                self._debug("Reload grid")
    600                 self.populate_tasks_tv(sw_remote)
     611                self.populate_tasks_tv()
    601612                if cursor:
    602613                        self._debug("Restoring cursor")
     
    607618        #def _reload_grid
    608619
    609         def manage_remove_responses(self,widget,response,model,task_name,task_serial,task_cmd,task_type,data):
     620        def manage_remove_responses(self,widget,response,model,task):
    610621                self.inf_question.hide()
    611622                if response==Gtk.ResponseType.OK:
    612                         self._debug("Removing task %s - %s - %s"%(task_name,task_serial,task_cmd))
    613                         if task_name in self.i18n['name'].keys():
    614                                 name=self.i18n['name'][task_name]
    615                         else:
    616                                 name=task_name
    617                         if task_cmd in self.i18n['cmd'].keys():
    618                                 cmd=self.i18n['cmd'][task_cmd]
    619                         else:
    620                                 cmd=task_cmd
    621                         if self.scheduler.remove_task(name,task_serial,cmd,task_type):
    622                                 self.populate_tasks_tv(task_type)
     623                        self._debug("Removing task %s"%(task))
     624                        if task['name'] in self.i18n['name'].keys():
     625                                task['name']=self.i18n['name'][task['name']]
     626                        if task['cmd'] in self.i18n['cmd'].keys():
     627                                task['cmd']=self.i18n['cmd'][task['cmd']]
     628                        if self.scheduler.remove_task(task):
     629                                self.populate_tasks_tv()
    623630                                self.tasks_tv.set_cursor(0)
    624631                        else:
     
    636643        def _manage_tasks(self,widget,event):
    637644                self._debug("Loading manage tasks form")
    638                 if self.btn_remote_tasks.get_active():
    639                         self.last_task_type='remote'
    640                 else:
    641                         self.last_task_type='local'
    642645                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
    643646                self.stack.set_visible_child_name("manage")
    644                 self._block_widget_state(False,self.btn_remote_tasks,self.handler_remote)
    645                 self._block_widget_state(False,self.btn_local_tasks,self.handler_local)
    646647        #def _manage_tasks     
    647648
     
    649650                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
    650651                self.stack.set_visible_child_name("tasks")     
    651                 if self.last_task_type=='remote':
    652                         self._block_widget_state(True,self.btn_remote_tasks,self.handler_remote)
    653                 else:
    654                         self._block_widget_state(True,self.btn_local_tasks,self.handler_local)
    655 
    656         ###
    657         #Changes the state of a widget blocking the signals
    658         ###
    659         def _block_widget_state(self,state,widget,handler):
    660                 widget.handler_block(handler)
    661                 widget.set_active(state)
    662                 GObject.timeout_add(100,widget.handler_unblock,handler)
    663         #def _block_widget_state
    664652       
    665653        def set_css_info(self):
  • taskscheduler/trunk/fuentes/scheduler-gui.install/usr/share/taskscheduler/rsrc/taskScheduler.ui

    r6742 r6811  
    8383        </child>
    8484        <child>
    85           <object class="GtkBox" id="box1">
    86             <property name="visible">True</property>
    87             <property name="can_focus">False</property>
    88             <property name="halign">start</property>
    89             <property name="hexpand">True</property>
    90             <property name="spacing">5</property>
    91             <property name="homogeneous">True</property>
    92             <child>
    93               <object class="GtkCheckButton" id="swt_remote">
    94                 <property name="label" translatable="yes">Remote task</property>
    95                 <property name="visible">True</property>
    96                 <property name="can_focus">True</property>
    97                 <property name="receives_default">False</property>
    98                 <property name="tooltip_text" translatable="yes">Schedule a task for all the clients</property>
    99                 <property name="xalign">0</property>
    100                 <property name="draw_indicator">True</property>
    101               </object>
    102               <packing>
    103                 <property name="expand">False</property>
    104                 <property name="fill">True</property>
    105                 <property name="position">0</property>
    106               </packing>
    107             </child>
    108             <child>
    109               <object class="GtkCheckButton" id="swt_local">
    110                 <property name="label" translatable="yes">Local task</property>
    111                 <property name="visible">True</property>
    112                 <property name="can_focus">True</property>
    113                 <property name="receives_default">False</property>
    114                 <property name="tooltip_text" translatable="yes">Schedule a task in this computer</property>
    115                 <property name="halign">end</property>
    116                 <property name="hexpand">True</property>
    117                 <property name="xalign">0</property>
    118                 <property name="draw_indicator">True</property>
    119               </object>
    120               <packing>
    121                 <property name="expand">False</property>
    122                 <property name="fill">True</property>
    123                 <property name="position">2</property>
    124               </packing>
    125             </child>
    126           </object>
    127           <packing>
    128             <property name="expand">False</property>
    129             <property name="fill">True</property>
    130             <property name="padding">5</property>
    131             <property name="position">1</property>
    132           </packing>
     85          <placeholder/>
    13386        </child>
    13487        <child>
     
    304257  </object>
    305258  <object class="GtkWindow" id="main_window">
     259    <property name="width_request">800</property>
    306260    <property name="can_focus">False</property>
    307     <property name="opacity">0.98039215686274506</property>
     261    <property name="opacity">0.93999999999999995</property>
    308262    <property name="valign">start</property>
    309263    <property name="resizable">False</property>
     
    375329                    <property name="hexpand">False</property>
    376330                    <child>
    377                       <object class="GtkBox" id="box_select_tasks">
     331                      <object class="GtkBox" id="nav_box">
    378332                        <property name="visible">True</property>
    379333                        <property name="can_focus">False</property>
     
    381335                        <property name="homogeneous">True</property>
    382336                        <child>
    383                           <object class="GtkToggleButton" id="btn_remote_tasks">
    384                             <property name="label" translatable="yes">Client tasks</property>
    385                             <property name="visible">True</property>
    386                             <property name="can_focus">True</property>
    387                             <property name="receives_default">True</property>
    388                             <property name="tooltip_text" translatable="yes">Show tasks scheduled for the clients</property>
    389                           </object>
    390                           <packing>
    391                             <property name="expand">False</property>
    392                             <property name="fill">True</property>
    393                             <property name="position">0</property>
    394                           </packing>
     337                          <placeholder/>
    395338                        </child>
    396339                        <child>
    397                           <object class="GtkToggleButton" id="btn_local_tasks">
    398                             <property name="label" translatable="yes">Local tasks</property>
    399                             <property name="visible">True</property>
    400                             <property name="can_focus">True</property>
    401                             <property name="receives_default">True</property>
    402                             <property name="tooltip_text" translatable="yes">Show tasks scheduled for this computer</property>
    403                           </object>
    404                           <packing>
    405                             <property name="expand">False</property>
    406                             <property name="fill">True</property>
    407                             <property name="position">1</property>
    408                           </packing>
     340                          <placeholder/>
     341                        </child>
     342                        <child>
     343                          <placeholder/>
     344                        </child>
     345                        <child>
     346                          <placeholder/>
    409347                        </child>
    410348                      </object>
     
    458396              </packing>
    459397            </child>
     398            <child>
     399              <object class="GtkBox" id="nav_bo">
     400                <property name="visible">True</property>
     401                <property name="can_focus">False</property>
     402                <property name="halign">center</property>
     403                <property name="hexpand">True</property>
     404                <child>
     405                  <object class="GtkButton" id="btn_all_tasks">
     406                    <property name="label" translatable="yes">button</property>
     407                    <property name="visible">True</property>
     408                    <property name="can_focus">True</property>
     409                    <property name="receives_default">True</property>
     410                  </object>
     411                  <packing>
     412                    <property name="expand">False</property>
     413                    <property name="fill">True</property>
     414                    <property name="position">0</property>
     415                  </packing>
     416                </child>
     417                <child>
     418                  <object class="GtkButton" id="btn_fixed_tasks">
     419                    <property name="label" translatable="yes">button</property>
     420                    <property name="visible">True</property>
     421                    <property name="can_focus">True</property>
     422                    <property name="receives_default">True</property>
     423                  </object>
     424                  <packing>
     425                    <property name="expand">False</property>
     426                    <property name="fill">True</property>
     427                    <property name="position">1</property>
     428                  </packing>
     429                </child>
     430                <child>
     431                  <object class="GtkButton" id="btn_repetitive_tasks">
     432                    <property name="label" translatable="yes">button</property>
     433                    <property name="visible">True</property>
     434                    <property name="can_focus">True</property>
     435                    <property name="receives_default">True</property>
     436                  </object>
     437                  <packing>
     438                    <property name="expand">False</property>
     439                    <property name="fill">True</property>
     440                    <property name="position">2</property>
     441                  </packing>
     442                </child>
     443                <child>
     444                  <object class="GtkButton" id="btn_daily_tasks">
     445                    <property name="label" translatable="yes">button</property>
     446                    <property name="visible">True</property>
     447                    <property name="can_focus">True</property>
     448                    <property name="receives_default">True</property>
     449                  </object>
     450                  <packing>
     451                    <property name="expand">False</property>
     452                    <property name="fill">True</property>
     453                    <property name="position">3</property>
     454                  </packing>
     455                </child>
     456              </object>
     457              <packing>
     458                <property name="expand">False</property>
     459                <property name="fill">True</property>
     460                <property name="position">2</property>
     461              </packing>
     462            </child>
    460463          </object>
    461464          <packing>
  • taskscheduler/trunk/fuentes/server-scheduler.install/usr/share/n4d/python-plugins/SchedulerServer.py

    r6763 r6811  
    1212        def __init__(self):
    1313                self.dbg=1
    14                 self.taskDir="/etc/scheduler/tasks.d"
    15                 self.schedTasksDir=self.taskDir+"/scheduled"
     14                self.tasks_dir="/etc/scheduler/tasks.d"
     15                self.schedTasksDir=self.tasks_dir+"/scheduled"
    1616                self.available_tasks_dir="/etc/scheduler/conf.d/tasks"
    1717                self.custom_tasks=self.available_tasks_dir+"/personal.json"
    18                 self.remote_tasks_dir=self.taskDir+"/remote"
    19                 self.local_tasks_dir=self.taskDir+"/local"
     18                self.remote_tasks_dir=self.tasks_dir+"/remote"
     19                self.local_tasks_dir=self.tasks_dir+"/local"
    2020        #def __init__
    2121
     
    2525        #def _debug
    2626
    27         def get_tasks(self,sw_remote=False,available=False):
     27        def get_tasks(self):
     28                return(self._read_wrkfiles(self.tasks_dir))
     29        #def get_tasks
     30
     31        def get_local_tasks(self):
     32                local_tasks={}
     33                tasks_data=self._read_wrkfiles(self.tasks_dir)['data'].copy()
     34                for task_serial in tasks_data.keys():
     35                        sw_continue=False
     36                        for task in task_serial.keys():
     37                                if ['spread_task'] in task.keys():
     38                                                if task['spread_task']==True:
     39                                                        sw_continue=True
     40                                                        break
     41                        if sw_continue:
     42                                continue
     43                        local_tasks.update(task_serial)
     44                return local_tasks
     45
     46        def get_remote_tasks(self):
     47                remote_tasks={}
     48                tasks_data=self._read_wrkfiles(self.tasks_dir)['data']
     49                for task_serial in tasks_data.keys():
     50                        sw_continue=False
     51                        for task in task_serial.keys():
     52                                if ['spread_task'] in task.keys():
     53                                        if task['spread_task']==True:
     54                                                remote_tasks.update(task_serial)
     55                                                break
     56                return remote_tasks
     57
     58        def get_available_tasks(self):
     59                return(self._read_wrkfiles(self.available_tasks_dir))
     60
     61        def _read_wrkfiles(self,folder):
    2862                tasks={}
    29                 wrkfiles=self._get_wrkfiles(sw_remote,available)
    30                 self._debug(wrkfiles)
     63                wrkfiles=self._get_wrkfiles(folder)
     64                self._debug(folder)
    3165                for wrkfile in wrkfiles:
    3266                        task=self._read_tasks_file(wrkfile)
     
    3670                self._debug(str(tasks))
    3771                return({'status':True,'data':tasks})
    38         #def get_tasks
    39 
    40         def get_available_tasks(self):
    41                 tasks={}
    42                 wrkfiles=self._get_wrkfiles(available=True)
    43                 self._debug(wrkfiles)
    44                 for wrkfile in wrkfiles:
    45                         task=self._read_tasks_file(wrkfile)
    46                         if task:
    47                                 tasks.update(task)
    48                 self._debug(str(tasks))
    49                 return({'status':True,'data':tasks})
    50 
    51         def _get_wrkfiles(self,sw_remote=False,available=False):
    52                 if available:
    53                         wrk_dir=self.available_tasks_dir
    54                 else:
    55                         if sw_remote:
    56                                 wrk_dir=self.remote_tasks_dir
    57                         elif sw_remote==False:
    58                                 wrk_dir=self.local_tasks_dir
    59                 if not os.path.isdir(wrk_dir):
    60                         os.makedirs(wrk_dir)
     72
     73        def _get_wrkfiles(self,folder):
    6174                wrkfiles=[]
    62                 for f in os.listdir(wrk_dir):
    63                         wrkfiles.append(wrk_dir+'/'+f)
     75                if not os.path.isdir(folder):
     76                        os.makedirs(folder)
     77                for f in os.listdir(folder):
     78                        wrkfiles.append(folder+'/'+f)
    6479                return wrkfiles
    6580        #def _get_wrkfiles
     
    7792        #def _read_tasks_file
    7893       
    79         def remove_task(self,task_type,task_name,task_serial,task_cmd):
    80                 if task_type=='local':
    81                         wrk_dir=self.local_tasks_dir
    82                 else:
    83                         wrk_dir=self.remote_tasks_dir
     94        def remove_task(self,task):
     95                wrk_dir=self.tasks_dir
    8496                self._debug("Removing task from system")
    8597                sw_del=False
    8698                msg=''
    87                 wrkfile=wrk_dir+'/'+task_name
     99                wrkfile=wrk_dir+'/'+task['name']
    88100                wrkfile=wrkfile.replace(' ','_')
    89                 task=self._read_tasks_file(wrkfile)
    90                 if task_name in task.keys():
    91                         if task_serial in task[task_name].keys():
    92                                 del task[task_name][task_serial]
     101                tasks=self._read_tasks_file(wrkfile)
     102                if task['name'] in tasks.keys():
     103                        if task['serial'] in tasks[task['name']].keys():
     104                                del tasks[task['name']][task['serial']]
    93105                                self._debug("Task deleted")
    94106                                sw_del=True
    95107
    96108                if sw_del:
    97                         task=self._serialize_task(task)
     109                        tasks=self._serialize_task(tasks)
    98110                        with open(wrkfile,'w') as json_data:
    99                                 json.dump(task,json_data,indent=4)
     111                                json.dump(tasks,json_data,indent=4)
    100112                        self._register_cron_update()
    101113                return ({'status':sw_del,'data':msg})
     
    114126
    115127        def write_tasks(self,task_type,tasks):
    116                 if task_type=='local':
    117                         wrk_dir=self.local_tasks_dir
    118                 else:
    119                         wrk_dir=self.remote_tasks_dir
     128                wrk_dir=self.tasks_dir
    120129                self._debug("Writing task info")
    121130                msg=''
     
    134143                        sched_tasks=json.loads(open(wrkfile).read())
    135144                        serial=len(sched_tasks[task_name])
     145                        data=self._fill_task_data(tasks[task_name][task_serial])
     146                        tasks[task_name][task_serial]=data
     147                        if task_type=='local':
     148                                tasks[task_name][task_serial].update({'spread':False})
     149                        elif task_type=="remote":
     150                                tasks[task_name][task_serial].update({'spread':True})
     151
    136152                        if task_serial in sched_tasks[task_name].keys():
     153                                #Modify
    137154                                self._debug("Modify item %s" % serial)
    138155                                sched_tasks[task_name][task_serial]=tasks[task_name][task_serial]
    139                                 #Modify
    140156                        else:
    141157                                #Add
    142158                                self._debug("Add item %s" % serial)
    143159                                serialized_data={}
     160                                data=self._fill_task_data(tasks[task_name][task_serial])
     161                                tasks[task_name][task_serial]=data
     162                                self._fill_task_data(tasks[task_name][task_serial])
    144163                                serialized_data[serial+1]=tasks[task_name][task_serial]
    145164                                sched_tasks[task_name].update(serialized_data)
    146165                else:
    147166                        self._debug("Add new item 1 to %s"%wrkfile)
     167                        data=self._fill_task_data(tasks[task_name]["0"])
     168                        tasks[task_name]["0"]=data
     169                        if task_type=='local':
     170                                tasks[task_name]["0"].update({'spread':False})
     171                        elif task_type=="remote":
     172                                tasks[task_name]["0"].update({'spread':True})
    148173                        tasks[task_name]={"1":tasks[task_name]["0"]}
    149174                        sched_tasks=tasks.copy()
     
    158183                self._debug("%s updated" % task_name)
    159184                return({'status':status,'data':msg})
     185        #def write_tasks
     186
     187        def _fill_task_data(self,task):
     188                task['kind']=[]
     189                if ['spread'] not in task.keys():
     190                        task['spread']=False
     191                #set task kind
     192                if task['dow']!='*':
     193                        task['kind'].append('daily')
     194                try:
     195                        int(task['mon'])
     196                        int(task['dom'])
     197                        int(task['h'])
     198                        int(task['m'])
     199                        task['kind']=['fixed']
     200                except:
     201                        if '/' in (task['mon']+task['dom']+task['h']+task['m']):
     202                                task['kind'].append('repeat')
     203                return task
     204
     205        def write_tasks_old(self,tasks):
     206                pass
    160207        #def write_tasks
    161208
Note: See TracChangeset for help on using the changeset viewer.