source: taskscheduler/trunk/fuentes/scheduler-gui.install/usr/share/taskscheduler/bin/taskScheduler.py @ 6813

Last change on this file since 6813 was 6813, checked in by Juanma, 19 months ago

Refactorized

  • Property svn:executable set to *
File size: 24.2 KB
Line 
1#! /usr/bin/python3
2# -*- coding: utf-8 -*-
3import gi
4gi.require_version('Gtk', '3.0')
5gi.require_version('PangoCairo', '1.0')
6import json
7import cairo
8import os
9import subprocess
10import shutil
11import threading
12import platform
13import subprocess
14import sys
15import time
16#import commands
17from gi.repository import Gtk, Gdk, GdkPixbuf, GObject, GLib, PangoCairo, Pango
18import time
19from taskscheduler.taskscheduler import TaskScheduler as scheduler
20from taskscheduler.cronParser import cronParser
21from detailDateBox import DetailBox as detailDateBox
22from edupals.ui.n4dgtklogin import *
23import signal
24signal.signal(signal.SIGINT, signal.SIG_DFL)
25
26import gettext
27gettext.textdomain('taskscheduler')
28_ = gettext.gettext
29
30BASE_DIR="/usr/share/taskscheduler/"
31#BASE_DIR="../share/taskscheduler/"
32GLADE_FILE=BASE_DIR+"rsrc/taskScheduler.ui"
33REMOVE_ICON=BASE_DIR+"rsrc/trash.svg"
34EDIT_ICON=BASE_DIR+"rsrc/edit.svg"
35NO_EDIT_ICON=BASE_DIR+"rsrc/no_edit.svg"
36LOCK_PATH="/var/run/taskScheduler.lock"
37WIDGET_MARGIN=6
38DBG=1
39
40class TaskScheduler:
41        def __init__(self):
42                self.is_scheduler_running()
43                try:
44                        self.flavour=subprocess.getoutput("lliurex-version -f")
45                except:
46                        self.flavour="client"
47                self.last_task_type='remote'
48                self.ldm_helper='/usr/sbin/sched-ldm.sh'
49                self.i18n={}
50                       
51        #def __init__           
52
53        def _debug(self,msg):
54                if DBG:
55                        print("taskScheduler: %s"%msg)
56        #def _debug
57
58        def is_scheduler_running(self):
59                if os.path.exists(LOCK_PATH):
60                        dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.ERROR, Gtk.ButtonsType.CANCEL, "Task Scheduler")
61                        dialog.format_secondary_text(_("There's another instance of Task Scheduler running."))
62                        dialog.run()
63                        sys.exit(1)
64        #def is_scheduler_running
65
66        def start_gui(self):
67                self.scheduler=scheduler()
68                builder=Gtk.Builder()
69                builder.set_translation_domain('taskscheduler')
70
71                self.stack = Gtk.Stack()
72                self.stack.set_transition_duration(1000)
73                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
74
75                glade_path=GLADE_FILE
76                builder.add_from_file(glade_path)
77
78                self.window=builder.get_object("main_window")
79                self.window.set_resizable(False)
80                self.main_box=builder.get_object("main_box")
81                self.login=N4dGtkLogin()
82                self.login.set_allowed_groups(['adm','teachers'])
83                desc=_("Welcome to the Task Scheduler for Lliurex.\nFrom here you can:\n<sub>* Schedule tasks in the local pc\n* Distribute tasks among all the pcs in the network\n*Show scheduled tasks</sub>")
84                self.login.set_info_text("<span foreground='black'>Task Scheduler</span>",_("Task Scheduler"),"<span foreground='black'>"+desc+"</span>\n")
85                self.login.set_info_background(image='taskscheduler',cover=True)
86                self.login.after_validation_goto(self._signin)
87                self.login.hide_server_entry()
88                self.inf_message=Gtk.InfoBar()
89                self.inf_message.set_show_close_button(True)
90                self.lbl_message=Gtk.Label("")
91                self.inf_message.get_action_area().add(self.lbl_message)
92                self.inf_message.set_halign(Gtk.Align.CENTER)
93                self.inf_message.set_valign(Gtk.Align.CENTER)
94                def hide(widget,response):
95                        self.inf_message.hide()
96                self.inf_message.connect('response',hide)
97#               self.inf_message.props.no_show_all=True
98
99                self.inf_question=Gtk.InfoBar() 
100                self.lbl_question=Gtk.Label("")
101                self.inf_question.get_action_area().add(self.lbl_question)
102                self.inf_question.add_button(Gtk.STOCK_CANCEL,Gtk.ResponseType.CANCEL)
103                self.inf_question.add_button(Gtk.STOCK_OK,Gtk.ResponseType.OK)
104                self.inf_question.set_halign(Gtk.Align.CENTER)
105                self.inf_question.set_valign(Gtk.Align.CENTER)
106#               self.inf_question.props.no_show_all=True
107                self.main_box.pack_start(self.inf_question,False,False,0)
108                self.main_box.pack_start(self.inf_message,False,False,0)
109                self.view_tasks_button_box=builder.get_object("view_tasks_button_box")
110                self.view_tasks_eb=builder.get_object("view_tasks_eventbox")
111                self.btn_signal_id=None
112                #Toolbar
113                self.toolbar=builder.get_object("toolbar")
114                self.toolbar.set_visible(False)
115                self.btn_add_task=builder.get_object("btn_add_task")
116                self.btn_add_task.connect("button-release-event", self.add_task_clicked)
117                self.btn_refresh_tasks=builder.get_object("btn_refresh_tasks")
118                self.btn_refresh_tasks.connect("button-release-event", self._reload_grid)
119                self.btn_manage_tasks=builder.get_object("btn_manage_tasks")
120                self.btn_manage_tasks.connect("button-release-event", self._manage_tasks)
121                self.txt_search=builder.get_object("txt_search")
122                self.txt_search.connect('changed',self.match_tasks)
123                self.nav_box=builder.get_object("nav_box")
124                self.nav_box.set_visible(False)
125                self.btn_fixed_sched=builder.get_object("btn_fixed_tasks")
126                self.btn_fixed_sched.set_visible(False)
127                self.btn_fixed_sched.set_no_show_all(True)
128                self.btn_daily_sched=builder.get_object("btn_daily_tasks")
129                self.btn_daily_sched.set_visible(False)
130                self.btn_daily_sched.set_no_show_all(True)
131                self.btn_repeat_sched=builder.get_object("btn_repetitive_tasks")
132                self.btn_repeat_sched.set_visible(False)
133                self.btn_repeat_sched.set_no_show_all(True)
134                self.btn_all_sched=builder.get_object("btn_all_tasks")
135                self.btn_all_sched.set_visible(False)
136                self.btn_all_sched.set_no_show_all(True)
137                self.btn_advanced_sched=Gtk.Button()
138                px=GdkPixbuf.Pixbuf.new_from_file("/home/lliurex/Circle-icons-countdown.svg")
139                img=Gtk.Image().new_from_pixbuf(px)
140                self.btn_fixed_sched.set_image(img)
141                self.btn_fixed_sched.set_image_position(Gtk.PositionType.TOP)
142                self.btn_fixed_sched.set_label(_("Fixed task"))
143                px=GdkPixbuf.Pixbuf.new_from_file("/home/lliurex/Circle-icons-calendar.svg")
144                img=Gtk.Image().new_from_pixbuf(px)
145                self.btn_daily_sched.set_image(img)
146                self.btn_daily_sched.set_image_position(Gtk.PositionType.TOP)
147                self.btn_daily_sched.set_label(_("Daily task"))
148                px=GdkPixbuf.Pixbuf.new_from_file("/home/lliurex/Circle-icons-swatches.svg")
149                img=Gtk.Image().new_from_pixbuf(px)
150                self.btn_repeat_sched.set_image(img)
151                self.btn_repeat_sched.set_image_position(Gtk.PositionType.TOP)
152                self.btn_repeat_sched.set_label(_("Repeat task"))
153                px=GdkPixbuf.Pixbuf.new_from_file("/home/lliurex/Circle-icons-genius.svg")
154                img=Gtk.Image().new_from_pixbuf(px)
155                self.btn_all_sched.set_image(img)
156                self.btn_all_sched.set_image_position(Gtk.PositionType.TOP)
157                self.btn_all_sched.set_label(_("All tasks"))
158                #Nav bar <--
159                #tasks list
160                self._load_task_list_gui(builder)
161                #Manage tasks
162                self._load_manage_tasks(builder)
163                #Icons
164                image=Gtk.Image()
165                image.set_from_file(REMOVE_ICON)               
166                self.remove_icon=image.get_pixbuf()
167                image.set_from_file(EDIT_ICON)         
168                self.edit_icon=image.get_pixbuf()
169                image.set_from_file(NO_EDIT_ICON)               
170                self.no_edit_icon=image.get_pixbuf()
171
172                self.stack.add_titled(self.tasks_box, "tasks", "Tasks")
173                self.stack.add_titled(self.manage_box, "manage", "Manage")
174                self.stack.add_titled(self.add_task_box, "add", "Add Task")
175                self.stack.add_titled(self.login, "login", "Login")
176                #Packing
177                self.main_box.pack_start(self.stack,True,False,5)
178
179                self.toolbar.props.no_show_all=True
180                self.nav_box.props.no_show_all=True
181                self.window.connect("destroy",self.quit)
182                self.window.set_resizable(False)
183                self.window.show_all()
184                self.inf_message.hide()
185                self.inf_question.hide()
186                self.set_css_info()
187                #Load stack
188                self.stack.set_transition_type(Gtk.StackTransitionType.NONE)
189                self.stack.set_visible_child_name("login")
190                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
191
192                Gtk.main()
193
194        #def start_gui
195
196        def _load_task_list_gui(self,builder):
197                self.tasks_box=builder.get_object("tasks_box")
198                self.tasks_label=builder.get_object("tasks_label")
199                self.tasks_tv=builder.get_object("tasks_treeview")
200                self.tasks_store=Gtk.ListStore(str,str,str,GdkPixbuf.Pixbuf,GdkPixbuf.Pixbuf,str,str,str,str)
201                self.tasks_store_filter=self.tasks_store.filter_new()
202                self.tasks_store_filter.set_visible_func(self.filter_tasklist)
203                self.tasks_tv.set_model(self.tasks_store_filter)
204                self.tasks_tv.connect("button-release-event",self.task_clicked)
205                self.tasks_tv.connect("cursor-changed",self.task_clicked)
206
207                column=Gtk.TreeViewColumn(_("Task"))
208                cell=Gtk.CellRendererText()
209                column.pack_start(cell,True)
210                column.add_attribute(cell,"markup",0)
211                column.add_attribute(cell,"cell_background",7)
212                column.add_attribute(cell,"foreground",8)
213                column.set_expand(True)
214                self.tasks_tv.append_column(column)
215               
216                column=Gtk.TreeViewColumn(_("Serial"))
217                cell=Gtk.CellRendererText()
218                column.pack_start(cell,True)
219                column.add_attribute(cell,"markup",1)
220                column.add_attribute(cell,"cell_background",7)
221                column.add_attribute(cell,"foreground",8)
222                column.set_expand(True)
223                column.set_visible(False)
224                self.tasks_tv.append_column(column)
225               
226                column=Gtk.TreeViewColumn(_("When"))
227                cell=Gtk.CellRendererText()
228                cell.set_property("alignment",Pango.Alignment.CENTER)
229                column.pack_start(cell,False)
230                column.add_attribute(cell,"markup",2)
231                column.add_attribute(cell,"cell_background",7)
232                column.add_attribute(cell,"foreground",8)
233                column.set_expand(True)
234                self.tasks_tv.append_column(column)             
235
236                column=Gtk.TreeViewColumn(_("Edit"))
237
238                cell=Gtk.CellRendererPixbuf()
239                column.pack_start(cell,True)
240                column.add_attribute(cell,"pixbuf",3)
241                column.add_attribute(cell,"cell_background",7)
242                self.col_edit=column
243                self.tasks_tv.append_column(column)
244               
245                column=Gtk.TreeViewColumn(_("Remove"))
246                cell=Gtk.CellRendererPixbuf()
247                column.pack_start(cell,True)
248                column.add_attribute(cell,"pixbuf",4)
249                column.add_attribute(cell,"cell_background",7)
250                self.col_remove=column
251                self.tasks_tv.append_column(column)
252
253                column=Gtk.TreeViewColumn(_("Command"))
254                cell=Gtk.CellRendererText()
255                column.pack_start(cell,True)
256                column.add_attribute(cell,"markup",5)
257                column.set_expand(True)
258                column.set_visible(False)
259                self.tasks_tv.append_column(column)
260               
261                column=Gtk.TreeViewColumn(_("Type"))
262                cell=Gtk.CellRendererText()
263                column.pack_start(cell,True)
264                column.add_attribute(cell,"markup",6)
265                column.set_expand(True)
266                column.set_visible(False)
267                self.tasks_tv.append_column(column)
268
269                self.tasks_tv.set_search_column(2)
270                self.tasks_tv.set_search_entry(self.txt_search)
271
272                #Add tasks
273                self.add_task_box=builder.get_object("add_task_box")
274                self.add_task_grid=detailDateBox(self.scheduler)
275                at_grid=self.add_task_grid.render_form(builder.get_object("add_task_grid"))
276                at_grid=builder.get_object("add_task_grid")
277                at_grid.set_hexpand(False)
278                self.cmb_task_names=builder.get_object("cmb_task_names")
279                self.cmb_task_cmds=builder.get_object("cmb_task_cmds")
280                builder.get_object("btn_back_add").connect("clicked", self.cancel_add_clicked)
281                builder.get_object("btn_cancel_add").connect("clicked", self.cancel_add_clicked)
282                self.btn_confirm_add=builder.get_object("btn_confirm_add")
283                self.btn_confirm_add.connect("clicked", self.save_task_details)
284        #def _load_task_list_gui
285
286        def _load_manage_tasks(self,builder):
287                self.manage_box=builder.get_object("manage_box")
288                custom_grid=builder.get_object("custom_grid")
289                custom_grid.set_margin_left(12)
290                custom_grid.set_margin_top(12)
291                txt_taskname=Gtk.Entry()
292                txt_taskname.set_tooltip_text(_("A descriptive name for the command"))
293                txt_taskname.set_placeholder_text(_("Task name"))
294                lbl_name=Gtk.Label(_("Task name"))
295                lbl_name.set_halign(Gtk.Align.END)
296                custom_grid.attach(lbl_name,0,0,1,1)
297                custom_grid.attach(txt_taskname,1,0,1,1)
298                cmb_cmds=Gtk.ComboBoxText()
299                cmds=self.scheduler.get_commands()
300                i18n_cmd={}
301                for cmd in cmds.keys():
302                        i18n_cmd[_(cmd)]=cmd
303                        cmb_cmds.append_text(_(cmd))
304
305                lbl_cmd=Gtk.Label(_("Command"))
306                lbl_cmd.set_halign(Gtk.Align.END)
307                custom_grid.attach(lbl_cmd,0,1,1,1)
308                custom_grid.attach(cmb_cmds,1,1,1,1)
309                chk_parm_is_file=Gtk.CheckButton(_("Needs a file"))
310                chk_parm_is_file.set_tooltip_text(_("Mark if the command will launch a file"))
311                btn_file=Gtk.FileChooserButton()
312                chk_parm_is_file.set_tooltip_text(_("Select the file that will be launched"))
313                chk_parm_is_file.connect('toggled',self._enable_filechooser,btn_file)
314                txt_params=Gtk.Entry()
315                txt_params.set_placeholder_text(_("Needed arguments"))
316                txt_params.set_tooltip_text(_("Put here the arguments for the command (if any)"))
317                lbl_arg=Gtk.Label(_("Arguments"))
318                lbl_arg.set_halign(Gtk.Align.END)
319                custom_grid.attach(lbl_arg,2,1,1,1)
320                custom_grid.attach(txt_params,3,1,1,1)
321                custom_grid.attach(chk_parm_is_file,2,0,1,1)
322                custom_grid.attach(btn_file,3,0,1,1)
323                btn_file.set_sensitive(False)
324                self.btn_apply_manage=builder.get_object("btn_apply_manage")
325                self.btn_apply_manage.connect("clicked",self._add_custom_task,txt_taskname,cmb_cmds,txt_params,chk_parm_is_file,btn_file,i18n_cmd)
326                self.btn_back_manage=builder.get_object("btn_back_manage")
327                self.btn_back_manage.connect("clicked",self._cancel_manage_clicked)
328                self.btn_cancel_manage=builder.get_object("btn_cancel_manage")
329                self.btn_cancel_manage.connect("clicked",self._cancel_manage_clicked)
330        #def _load_manage_tasks
331       
332        def _enable_filechooser(self,widget,filechooser):
333                if widget.get_active():
334                        filechooser.set_sensitive(True)
335                else:
336                        filechooser.set_sensitive(False)
337        #def _enable_filechooser
338
339        def _add_custom_task(self,widget,w_name,w_cmd,w_parms,w_chk,w_file,i18n_cmd):
340                name=w_name.get_text()
341                cmd=w_cmd.get_active_text()
342                cmd_desc=i18n_cmd[cmd]
343                parms=w_parms.get_text()
344                cmd=self.scheduler.get_command_cmd(cmd_desc)
345                if w_chk.get_active():
346                        parms=parms+' '+w_file.get_uri().replace('file://','')
347                if self.scheduler.write_custom_task(name,cmd,parms):
348                        self._show_info(_("Task saved"))
349                else:
350                        self._show_info(_("Permission denied"))
351        #def _add_custom_task
352
353        def _signin(self,user=None,pwd=None,server=None,data=None):
354                self.scheduler.set_credentials(user,pwd,server)
355                self.stack.set_visible_child_name("tasks")
356                self.populate_tasks_tv()
357                self.toolbar.show()
358                self.nav_box.show()
359        #def _signin
360
361        def populate_tasks_tv(self,sw_remote=False):
362                self._debug("Populating task list")
363                self.scheduled_tasks={}
364                tasks=[]
365                sw_tasks=False
366                tasks=self.scheduler.get_scheduled_tasks(sw_remote)
367                self.tasks_store.clear()
368                if type(tasks)==type({}):       
369                        parser=cronParser()
370                        self.i18n['cmd']={}
371                        self.i18n['name']={}
372                        for task_name in tasks.keys():
373                                for serial in tasks[task_name].keys():
374                                        task=tasks[task_name][serial]
375                                        task['sw_remote']=''
376                                        color_palette=['goldenrod','DarkSlateGrey','Burlywood','DarkSlateGrey','DarkSlateBlue','bisque','LightSteelBlue','DarkSlateGrey']
377                                        bg_color=color_palette[0]
378                                        fg_color=color_palette[1]
379                                        if 'kind' in task.keys():
380                                                if 'fixed' in task['kind']:
381                                                        bg_color=color_palette[2]
382                                                        fg_color=color_palette[3]
383                                                elif 'repeat' in task['kind']:
384                                                        bg_color=color_palette[4]
385                                                        fg_color=color_palette[5]
386                                                elif 'daily' in task['kind']:
387                                                        bg_color=color_palette[6]
388                                                        fg_color=color_palette[7]
389                                        else:
390                                                task['kind']=''
391                                        remote='Local task'
392                                        if 'spread' in task.keys():
393                                                if task['spread']==True:
394                                                        remote="Client task"
395                                        else:
396                                                task['spread']=False
397                                        self.scheduled_tasks[task_name]=tasks[task_name]
398                                        sw_tasks=True
399                                        parsed_calendar=''
400                                        parsed_calendar=parser.parse_taskData(task)
401                                        task['cmd']=task['cmd'].replace(self.ldm_helper+' ','')
402                                        task['action']=self.scheduler.get_task_description(task['cmd'])
403                                        if 'name' in task.keys():
404                                                name=task['name']
405                                        else:
406                                                name=_(task['action'])
407                                        self.i18n['cmd'].update({name:task['action']})
408                                        self.i18n['name'].update({_(task_name):task_name})
409                                        img=self.edit_icon
410                                        if 'protected' in task.keys():
411                                                if task['protected']==True:
412                                                        img=self.no_edit_icon
413                                        row=self.tasks_store.append(("<span font='Roboto'><b>"+name+"</b></span>\n"+\
414                                                                "<span font='Roboto' size='small'><i>"+\
415                                                                _(task_name)+"</i></span>",serial,"<span font='Roboto' size='small'>"+\
416                                                                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))
417        #def populate_tasks_tv
418       
419        def filter_tasklist(self,model,iterr,data):
420                sw_match=True
421                match=self.txt_search.get_text().lower()
422                task_data=model.get_value(iterr,0).split('\n')
423                task_sched_data=model.get_value(iterr,2).split('\n')
424                task_cmd=task_data[0][task_data[0].find("<b>")+3:task_data[0].find("</b>")]
425                task_name=task_data[1][task_data[1].find("<i>")+3:task_data[1].find("</i>")]
426                task_sched=task_sched_data[0][task_sched_data[0].find("ll'>")+4:task_sched_data[0].find("</span>")]
427
428                task_text=task_cmd+' '+task_name+' '+task_sched
429                if match and match not in task_text.lower():
430                        sw_match=False
431                return sw_match
432        #def filter_tasklist
433
434        def match_tasks(self,widget):
435                self.tasks_store_filter.refilter()
436                GObject.timeout_add(100,self.tasks_tv.set_cursor,0)
437        #def match_tasks
438
439        def _process_model(self,model,data):
440                task={}
441                task['data']=model[data][0].split('\n')
442                if _("client task") in model[data][2]:
443                        task['spread']=True
444                else:
445                        task['spread']=False
446                task['serial']=model[data][1].split('\n')[0]
447                cmd=task['data'][0][task['data'][0].find("<b>")+3:task['data'][0].find("</b>")]
448                if cmd in self.i18n['cmd'].keys():
449                        task['cmd']=self.i18n['cmd'][cmd]
450                else:
451                        task['cmd']=cmd
452
453                name=task['data'][1][task['data'][1].find("<i>")+3:task['data'][1].find("</i>")]
454                if name in self.i18n['name'].keys():
455                        task['name']=self.i18n['name'][name]
456                else:
457                        task['name']=name
458
459                task['serial']=model[data][1]
460                return(task)
461
462        def _click_on_list(self,event):
463                action=''
464                try:
465                        row=self.tasks_tv.get_path_at_pos(int(event.x),int(event.y))
466                except Exception as e:
467                        self._debug(e)
468                if row:
469                        if row[1]==self.col_remove:
470                                action='remove'
471                        elif row[1]==self.col_edit:
472                                action='edit'
473                self._debug(action)
474                return action
475
476        def task_clicked(self,treeview,event=None):
477                self._debug("task clicked %s"%event)
478                selection=self.tasks_tv.get_selection()
479                model,data=selection.get_selected()
480                if not data:
481                        return
482                task={}
483                action=''
484                if event!=None:
485                        action=self._click_on_list(event)
486                task=self._process_model(model,data)
487                if action=='remove':
488                        self.lbl_question.set_text(_("Are you sure to delete this task?"))
489                        for widget in self.main_box.get_children():
490                                widget.set_sensitive(False)
491                        self.inf_question.set_sensitive(True)
492                        self.inf_question.show_all()
493                        try:
494                                self.inf_question.disconnect_by_func(self.manage_remove_responses)
495                        except:
496                                pass
497                        self.inf_question.connect('response',self.manage_remove_responses,model,task)
498                elif action=='edit':
499                        if task['name'] in self.scheduled_tasks.keys():
500                                if task['serial'] in self.scheduled_tasks[task['name']].keys():
501                                        task['data']=self.scheduled_tasks[task['name']][task['serial']]
502                                        self._debug("Loading details of task %s of group %s"% (task['serial'],task['name']))
503                                        self.add_task_grid.set_task_data(task)
504                                        self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
505                                        self.cmb_task_names.append_text(_(task['name']))
506                                        self.cmb_task_cmds.append_text(_(task['cmd']))
507                                        self.cmb_task_names.set_active(0)
508                                        self.cmb_task_cmds.set_active(0)
509                                        self.add_task_grid.load_task_details()
510                                        if 'protected' in task['data'].keys():
511                                                if task['data']['protected']:
512                                                        self.btn_confirm_add.set_sensitive(False)
513                                        else:
514                                                self.btn_confirm_add.set_sensitive(True)
515                                        self.stack.set_visible_child_name("add")
516        #def task_clicked                       
517
518        def save_task_details(self,widget):
519                task={}
520                name=self.cmb_task_names.get_active_text()
521                task['name']=self.i18n['name'][name]
522                action=self.cmb_task_cmds.get_active_text()
523                i18n_action=self.i18n['cmd'][action]
524                tasks=self.scheduler.get_available_tasks()
525                task['cmd']=tasks[task['name']][i18n_action]
526                self.add_task_grid.update_task_data(task)
527                task=self.add_task_grid.get_task_details()
528
529                self._debug("Writing task info...%s"%task)
530                for key in task.keys():
531                        print(key)
532                        for data in task[key].keys():
533                                if task[key][data]['spread']==False:
534                                        status=self.scheduler.write_tasks(task,'local')
535                                else:
536                                        status=self.scheduler.write_tasks(task,'remote')
537                        break
538                if status:
539                        self._show_info(_("Task saved"))
540                else:
541                        self._show_info(_("Permission denied"))
542                return()
543        #def save_task_details
544
545        def view_tasks_clicked(self,widget,sw_remote):
546                if widget:
547                        if not widget.get_active():
548                                return True
549                self._debug("loading tasks (remote: %s)" % sw_remote)
550                if sw_remote:
551                        self.last_task_type='remote'
552                else:
553                        self.last_task_type='local'
554                self._debug("Task clicked")
555                self.populate_tasks_tv()
556                self.tasks_tv.set_model(self.tasks_store_filter)
557                self.tasks_tv.set_cursor(0)
558                if self.stack.get_visible_child_name!='tasks':
559                        self.stack.set_visible_child_name("tasks")
560        #def view_tasks_clicked
561
562        def load_add_task_details(self):
563                tasks=[]
564                names=[]
565                self.cmb_task_names.remove_all()
566                tasks=self.scheduler.get_available_tasks()
567                for name in tasks.keys():
568                        if name not in names:
569                                names.append(name)
570                                self.i18n['name'].update({_(name):name})
571                                self.cmb_task_names.append_text(_(name))
572               
573                self.cmb_task_names.connect('changed',self.load_add_task_details_cmds,tasks)
574                self.cmb_task_names.set_active(0)
575        #def load_add_task_details
576
577        def load_add_task_details_cmds(self,widget,tasks):
578                actions=[]
579                self.i18n['cmd']={}
580                self.cmb_task_cmds.remove_all()
581                task_name=self.cmb_task_names.get_active_text()
582                if task_name:
583                        orig_name=self.i18n['name'][task_name]
584                        for action in tasks[orig_name].keys():
585                                if action not in actions:
586                                        self.i18n['cmd'].update({_(action):action})
587                                        actions.append(action)
588                                        self.cmb_task_cmds.append_text(_(action))
589                self.cmb_task_cmds.set_active(0)
590        #def load_add_task_details_cmds
591       
592        def update_task(self,widget,data=None):
593                self._debug("Updating task")
594                if self.task_details_grid.update_task_details():
595                        self._show_info(_('Task updated'))
596                        self._reload_grid()
597                else:
598                        self._show_info(_('Permission denied'))
599               
600        #def update_task
601
602        def add_task_clicked(self,widget,event):
603                self._debug("Loading new task form")
604                self.add_task_grid.clear_screen()
605                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
606                self.stack.set_visible_child_name("add")
607                self.load_add_task_details()
608        #def add_task_clicked   
609
610        def cancel_add_clicked(self,widget,event=None):
611                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
612                self.stack.set_visible_child_name("tasks")     
613                self._debug("Cancel add clicked")
614                self._reload_grid()
615        #def cancel_add_clicked
616
617        def _reload_grid(self,widget=None,data=None):
618                cursor=self.tasks_tv.get_cursor()[0]
619                self._debug("CURSOR %s"%widget)
620                self._debug("Reload grid")
621                self.populate_tasks_tv()
622                if cursor:
623                        self._debug("Restoring cursor")
624                        self.tasks_tv.set_cursor(cursor)
625
626                if type(widget)==type(Gtk.CheckButton()):
627                        self.task_details_grid.chk_node.connect("toggled",self._reload_grid)
628        #def _reload_grid
629
630        def manage_remove_responses(self,widget,response,model,task):
631                self.inf_question.hide()
632                if response==Gtk.ResponseType.OK:
633                        self._debug("Removing task %s"%(task))
634                        if task['name'] in self.i18n['name'].keys():
635                                task['name']=self.i18n['name'][task['name']]
636                        if task['cmd'] in self.i18n['cmd'].keys():
637                                task['cmd']=self.i18n['cmd'][task['cmd']]
638                        if self.scheduler.remove_task(task):
639                                self.populate_tasks_tv()
640                                self.tasks_tv.set_cursor(0)
641                        else:
642                                self._show_info(_("Permission denied"))
643                for widget in self.main_box.get_children():
644                        widget.set_sensitive(True)
645        #def manage_remove_responses
646
647        def _show_info(self,msg):
648                self.lbl_message.set_text(_(msg))
649                self.inf_message.show_all()
650                GObject.timeout_add(5000,self.inf_message.hide)
651        #def _show_info
652       
653        def _manage_tasks(self,widget,event):
654                self._debug("Loading manage tasks form")
655                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
656                self.stack.set_visible_child_name("manage")
657        #def _manage_tasks     
658
659        def _cancel_manage_clicked(self,widget):
660                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
661                self.stack.set_visible_child_name("tasks")     
662       
663        def set_css_info(self):
664       
665                css = b"""
666                #WHITE_BACKGROUND {
667                        background-image:-gtk-gradient (linear, left top, left bottom, from (#ffffff),  to (#ffffff));;
668               
669                }
670
671                #BLUE_FONT {
672                        color: #3366cc;
673                        font: Roboto Bold 11;
674                       
675                }       
676               
677
678                #TASKGRID_FONT {
679                        color: #3366cc;
680                        font: Roboto 11;
681                       
682                }
683
684                #LABEL_OPTION{
685               
686                        color: #808080;
687                        font: Roboto 11;
688                }
689
690                #ERROR_FONT {
691                        color: #CC0000;
692                        font: Roboto Bold 11;
693                }
694                """
695                self.style_provider=Gtk.CssProvider()
696                self.style_provider.load_from_data(css)
697                Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),self.style_provider,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
698               
699                self.window.set_name("WHITE_BACKGROUND")
700                self.tasks_box.set_name("WHITE_BACKGROUND")
701        #def set_css_info       
702
703        def quit(self,widget,event=None):
704                Gtk.main_quit() 
705        #def quit       
706
707#class TaskScheduler
708
709GObject.threads_init()
710t=TaskScheduler()
711t.start_gui()           
Note: See TracBrowser for help on using the repository browser.