source: lliurex-gdrive/trunk/fuentes/lliurex-gdrive-indicator.install/usr/bin/lliurexGdriveIndicator @ 7081

Last change on this file since 7081 was 7081, checked in by jrpelegrina, 3 years ago

WIP in changes to install in non lliurex distro

  • Property svn:executable set to *
File size: 24.6 KB
Line 
1#!/usr/bin/env python
2
3import gi
4gi.require_version('Gtk', '3.0')
5from gi.repository import Gtk, Pango, GdkPixbuf, Gdk, Gio, GObject, GLib
6gi.require_version('AppIndicator3', '0.1')
7from gi.repository import AppIndicator3 as appindicator
8
9import os
10from os import listdir
11from os.path import isfile, isfile,isdir,join
12import threading
13import subprocess
14import sys
15import gettext
16import json
17import random
18import notify2
19import time
20import datetime
21import copy
22
23
24import pyinotify
25from pyinotify import WatchManager, Notifier, ThreadedNotifier, EventsCodes, ProcessEvent
26
27import signal
28signal.signal(signal.SIGINT, signal.SIG_DFL)
29
30import lliurexgdrive
31
32import gettext
33gettext.textdomain('lliurex-gdrive')
34_ = gettext.gettext
35
36LOCK_INDICATOR="~/.config/lliurex-google-drive-profiles/lgdIndicator.lock"
37LOCK_GUI="~/.config/lliurex-google-drive-profiles/lgdGUI.lock"
38RSRC="/usr/share/lliurex-gdrive/"
39MOUNT_ON_IMAGE=RSRC+"rsrc/mount_on.png"
40MOUNT_OFF_IMAGE=RSRC+"rsrc/mount_off.png"
41MOUNT_WARNING_IMAGE=RSRC+"rsrc/mount_warning.png"
42SP1=RSRC+"rsrc/sp1.png"
43SP2=RSRC+"rsrc/sp2.png"
44SP3=RSRC+"rsrc/sp3.png"
45SP4=RSRC+"rsrc/sp4.png"
46SP5=RSRC+"rsrc/sp5.png"
47SP6=RSRC+"rsrc/sp6.png"
48SP7=RSRC+"rsrc/sp7.png"
49SP8=RSRC+"rsrc/sp8.png"
50
51TIME_CHECK_STATUS=900000
52
53class LliurexGdriveIndicator:
54
55        WATCH_DIR=os.path.expanduser("~/.config/lliurex-google-drive-profiles/")
56       
57        def __init__(self,icon_name):
58               
59                self.lock_gui=os.path.expanduser(LOCK_GUI)
60                self.lock_indicator=os.path.expanduser(LOCK_INDICATOR)         
61
62                self.LliurexGoogleDriveManager=lliurexgdrive.LliurexGoogleDriveManager()
63                self.app_indicator=appindicator.Indicator.new("lliurex-gdrive",icon_name,appindicator.IndicatorCategory.APPLICATION_STATUS)
64                self.app_indicator.set_status(appindicator.IndicatorStatus.ACTIVE)
65                self.menu = Gtk.Menu()
66               
67                self.menu.add_events(Gdk.EventMask.ALL_EVENTS_MASK)
68                self.app_indicator.set_menu(self.menu)
69               
70                self.profiles_info=self.LliurexGoogleDriveManager.profiles_config.copy()
71                self.current_status={}
72                self.blacklist=['.Trash','.Trash-1000']
73                self.init_files=[]
74                self.update_files=[]
75                self.local_changes={}
76                self.notifications_list=[]
77
78                       
79                self.createLockToken()
80                self.check_initial_connection()
81                self.populate_menu()
82                self.start_inotify()
83                self.sync_threads={}
84                self.result_sync_threads={}
85                self.profile_clicked=[]
86                self.sp_cont={}
87                self.sp_img={}
88                self.checking_status=False
89               
90
91                GLib.timeout_add(TIME_CHECK_STATUS,self.check_status)
92               
93        #def __init__
94
95        def check_initial_connection(self):
96               
97                self.initial_connection=self.LliurexGoogleDriveManager.check_google_connection()
98                return
99
100        #def check_initial_connection   
101
102        def generate_sync_threads(self,profile):
103               
104                id=int(random.random()*1000)           
105                t=threading.Thread(target=self.check_sync,args=(id,profile))
106                t.daemon=True
107                t.start()
108                self.sync_threads[id]={}
109                self.sync_threads[id]["thread"]=t
110                self.result_sync_threads[id]={}
111                return id
112
113        #def generate_sync_threads     
114       
115        def init_connect_thread(self):
116               
117                self.check_connect_t=threading.Thread(target=self.check_connect)
118                self.check_connect_t.daemon=True
119                self.check_connect_t.start()
120
121        #def init_connect_thread       
122               
123        def createLockToken(self):
124
125                #self.lockpath=os.path(LOCK_INDICATOR)
126                if not os.path.exists(self.lock_indicator):
127                        f=open(self.lock_indicator,'w')
128                        f.close
129
130        #def createLockToken
131                       
132        def start_inotify(self):
133
134                inotify_t=threading.Thread(target=self._inotify)
135                inotify_t.daemon=True
136                inotify_t.start()
137
138        #def start_inotif
139
140
141        def _inotify(self):
142               
143               
144                wm=WatchManager()
145                mask= pyinotify.IN_CLOSE_WRITE
146                     
147                       
148                class Process_handler(ProcessEvent):
149                               
150                        def __init__(self,main):
151                               
152                                self.main=main
153                       
154                               
155                        def process_IN_CLOSE_WRITE(self,event):
156
157                                self.main.update_info()
158                                self.main.initial_connection=True
159
160                                if os.path.expanduser(event.pathname)==os.path.join(LliurexGdriveIndicator.WATCH_DIR,"configProfiles"):
161                                       
162                                        for profile in self.main.update_profiles:
163                                                mountpoint_new=self.main.update_profiles[profile]["mountpoint"]
164                                                gdriveFolder_new=self.main.update_profiles[profile]["gdrive_folder"]
165                                                if not profile in self.main.profiles_info:
166                                                        self.main.add_menu_item(profile,mountpoint_new)
167                                                        wdd=wm.add_watch(mountpoint_new,mask,rec=True)
168                                                else:
169                                                        mountpoint_old=self.main.profiles_info[profile]["mountpoint"]
170                                                        gdriveFolder_old=self.main.profiles_info[profile]["gdrive_folder"]
171                                                        if (mountpoint_new != mountpoint_old) or (gdriveFolder_new != gdriveFolder_old): 
172                                                                '''
173                                                                try:
174                                                                        ide=wm.get_wd(mountpoint_old)
175                                                                        if id !=None:
176                                                                                wdd=wm.rm_watch(ide,rec=False)
177                                                                except Exception as e:
178                                                                        print "ERROR"
179                                                                        print str(e)
180                                                                        pass   
181                                                                '''     
182                                                                self.main.remove_folder_info(profile)
183                                                                self.main.init_folders_info(profile,mountpoint_new)
184                                                                wdd=wm.add_watch(mountpoint_new,mask,rec=True)
185
186                                        profile_rm=""
187                                        for item in self.main.menu.get_children():
188                                                if item.profile !="":
189                                                        if not item.profile in self.main.update_profiles:
190                                                                self.main.menu.remove(item)
191                                                                profile_rm=item.profile
192
193                                        if profile_rm !="":
194                                                mountpoint=self.main.profiles_info[profile_rm]["mountpoint"]
195                                                '''
196                                                try:
197                                                        ide=wm.get_wd(mountpoint)
198                                                        wdd=wm.rm_watch(ide,rec=False)
199                                                except Exception as e:
200                                                        print str(e)
201                                                        pass
202                                                '''     
203
204                                                self.main.remove_folder_info(profile_rm)                               
205                                                               
206
207                                        self.main.profiles_info=self.main.update_profiles.copy()
208                                        self.main.menu.show_all()
209
210                                else:
211                                        if 'ountToken' in os.path.basename(event.pathname):
212                                                        tmp_profile=os.path.basename(event.pathname).split("__")[0]
213                                                        tmp_profile=tmp_profile.decode("utf-8")
214                                                        for item in self.main.profiles_info:
215                                                                if item==tmp_profile:
216                                                                        tmp_mountpoint=self.main.profiles_info[item]["mountpoint"]
217                                                                        '''
218                                                                        try:
219                                                                                ide=wm.get_wd(tmp_mountpoint)
220                                                                                if id !=None:
221                                                                                        wdd=wm.rm_watch(ide,rec=False)
222                                                                        except Exception as e:
223                                                                                print str(e)
224                                                                                pass
225                                                                        '''     
226                                                                        self.main.remove_folder_info(item)             
227                                                                        if 'MountToken' in os.path.basename(event.pathname):
228                                                                                self.main.init_folders_info(item,tmp_mountpoint)
229                                                                                wdd=wm.add_watch(tmp_mountpoint,mask,rec=True)
230                                                                       
231                                        else:   
232                                                time.sleep(2)
233                                                t=join(event.path,event.name)
234                                                if isfile(t):
235                                                       
236                                                        '''
237                                                        for item in self.main.profiles_info:
238                                                                tmp_mount=self.main.profiles_info[item]["mountpoint"]
239                                                               
240                                                                if event.path in tmp_mount:
241                                                                        cmd="google-drive-ocamlfuse -cc -label %s"%item
242                                                                        os.system(cmd)
243                                                        '''             
244                                                                                       
245                                                        try:
246                                                               
247                                                                state=os.stat(t)
248                                                               
249                                                        except Exception as e:
250                                                                print str(e)
251                                                                t=t.split('trashinfo')
252                                                                t=t[0]+'trashinfo'
253                                                                state=os.stat(t)
254                                                               
255                                                        t=t.decode("utf-8")                     
256                                                        access=datetime.datetime.fromtimestamp(state.st_mtime)
257                                                        self.main.local_changes[t]=access
258                                                                               
259               
260                notifier=Notifier(wm,Process_handler(self))
261                wdd=wm.add_watch(LliurexGdriveIndicator.WATCH_DIR,mask,rec=True)
262               
263                for profile in self.profiles_info:
264                        path=os.path.expanduser(self.profiles_info[profile]["mountpoint"])
265                        wdd=wm.add_watch(path,mask,rec=True)
266
267               
268                while True:
269                        try:
270                               
271                                notifier.process_events()
272
273                                if notifier.check_events():
274                                        notifier.read_events()
275
276                        except Exception as e:
277                                print str(e)
278                                notifier.stop()
279               
280                return False
281                       
282       
283        #def _inotify
284
285        def update_info(self):
286
287                f=open(self.LliurexGoogleDriveManager.config_file)
288
289                try:
290                        self.update_profiles=json.load(f)
291                except:
292                        self.update_profiles={}
293               
294                f.close()
295
296        #def update_info       
297       
298        def add_menu_item(self,profile,mountpoint):
299
300                if self.initial_connection:
301                        status_info=self.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
302                        info=self.item_status_info(status_info)
303                        self.current_status[profile]=status_info["status"]     
304                else:
305                        status_info={}
306                        status_info['status']=None
307                        status_info['size']=0
308                        status_info['used']=0
309                        info=self.item_status_info(status_info)
310                        self.current_status[profile]=None
311                               
312                label_item=profile     
313                item=Gtk.ImageMenuItem()
314                item.set_label(label_item)
315                item.set_image(info["img"])
316                item.set_tooltip_text(info["tooltip"])
317                item.profile=profile
318                item.size=False
319                item.status=True
320                item.set_always_show_image(True)
321                item.connect("activate",self.item_clicked,profile)
322                self.menu.insert(item,0)
323
324               
325                item=Gtk.MenuItem()
326                label_item=info["used_size"]
327                item.set_label(label_item)
328                item.profile=profile
329                item.size=True
330                item.status=False
331                self.menu.insert(item,1)
332
333                item=Gtk.MenuItem()
334                label_item=_("Open folder")
335                item.set_label(label_item)
336                item.connect("activate",self.open_folder,profile)
337                item.profile=profile
338                item.size=False
339                item.status=False
340                self.menu.insert(item,2)
341
342                item=Gtk.MenuItem()
343                label_item=_("Update cache")
344                item.set_label(label_item)
345                item.set_tooltip_text(_("Click if do not see all the files in the Google Drive account"))
346                item.connect("activate",self.refresh_cache_clicked,profile)
347                item.profile=profile
348                item.size=False
349                item.status=False
350                self.menu.insert(item,3)
351
352                item=Gtk.SeparatorMenuItem()
353                item.profile=profile
354                item.size=False
355                item.status=False
356                self.menu.insert(item,4)
357                self.init_folders_info(profile,mountpoint)
358
359
360        #def add_menu_item     
361
362
363        def populate_menu(self,empty=True):
364               
365               
366                if empty:
367                        for c in self.menu.get_children():
368                                self.menu.remove(c)
369               
370               
371                for profile in self.profiles_info:
372                        mountpoint=self.profiles_info[profile]["mountpoint"]
373                        self.add_menu_item(profile,mountpoint)
374                       
375                       
376                item=Gtk.ImageMenuItem()
377                label_item=_("Open Lliurex GDrive")
378                item.set_label(label_item)
379                img=Gtk.Image()
380                img.set_from_stock(Gtk.STOCK_PREFERENCES,Gtk.IconSize.MENU)
381                item.set_image(img)
382                item.set_always_show_image(True)
383                item.connect("activate",self.open_gui)
384                item.profile=""
385                item.size=False
386                item.status=False
387                self.menu.append(item)
388
389                item=Gtk.ImageMenuItem()
390                img=Gtk.Image()
391                img.set_from_stock(Gtk.STOCK_CLOSE,Gtk.IconSize.MENU)
392                item.set_image(img)
393                item.set_always_show_image(True)
394                label_item=_("Close")
395                item.set_label(label_item)
396                item.connect("activate",self.quit)
397                item.profile=""
398                item.size=False
399                item.status=False
400                self.menu.append(item)
401
402
403                self.menu.show_all()
404               
405               
406        #def populate_menu
407       
408        def init_folders_info(self,profile,mountpoint):
409
410                self.folders_info={}
411                tmp={}
412                self.folders_info['profile']=profile
413                tmp['profile']=profile
414                tmp['notifications']=[]
415                self.notifications_list.append(tmp)
416                self.files=set()
417                self.controlDirectory(mountpoint)
418                self.folders_info['files']=self.files
419                self.init_files.append(self.folders_info)
420       
421        #def init_folders_info                         
422
423
424        def controlDirectory(self,path):
425               
426               
427                for item in listdir(path):
428                        if item not in self.blacklist:
429                               
430                                t=join(path,item)
431
432                                if isfile(t):
433                                       
434                                        compartido=False
435                                        state=os.stat(t)
436                                        access=datetime.datetime.fromtimestamp(state.st_mtime)
437                                        tmp=t+":__"+str(access)
438                                       
439                                        self.files.add(tmp)
440                                else:
441                                        if isdir(t):
442                                                self.controlDirectory(t)       
443
444        #def controlDirectory                                   
445                                               
446        def remove_folder_info(self,profile):
447
448                i=0
449                for item in self.init_files:
450                        if profile ==item["profile"]:
451                                self.init_files.pop(i)
452                        i=i+1   
453
454                i=0
455                for item in self.notifications_list:
456                        if profile ==item["profile"]:
457                                self.notifications_list.pop(i)
458
459                        i=i+1           
460
461        #def remove_folder_info         
462
463
464        def item_clicked(self,widget,profile):
465       
466                if profile not in self.profile_clicked:
467                        self.profile_clicked.append(profile)
468                        id=self.generate_sync_threads(profile)
469                        self.sp_cont[id]=0
470                        self.sp_img[id]=Gtk.Image.new_from_file(SP1)
471                        GLib.timeout_add(100,self.pulsate_check_sync,id,widget,profile)
472                       
473               
474        #def item_clicked
475
476        def spinner_sync(self,id):
477       
478                if self.sp_cont[id]>80:
479                        self.sp_cont[id]=0
480                       
481                if self.sp_cont[id]==0:
482                        img=Gtk.Image.new_from_file(SP1)
483                        self.sp_img[id]=img
484                elif self.sp_cont[id]==10:
485                        img=Gtk.Image.new_from_file(SP2)
486                        self.sp_img[id]=img                     
487                elif self.sp_cont[id]==20:
488                        img=Gtk.Image.new_from_file(SP3)
489                        self.sp_img[id]=img
490                elif self.sp_cont[id]==30:
491                        img=Gtk.Image.new_from_file(SP4)
492                        self.sp_img[id]=img
493                elif self.sp_cont[id]==40:
494                        img=Gtk.Image.new_from_file(SP5)
495                        self.sp_img[id]=img     
496                elif self.sp_cont[id]==50:
497                        img=Gtk.Image.new_from_file(SP6)
498                        self.sp_img[id]=img     
499                elif self.sp_cont[id]==60:
500                        img=Gtk.Image.new_from_file(SP7)
501                        self.sp_img[id]=img     
502                elif self.sp_cont[id]==70:
503                        img=Gtk.Image.new_from_file(SP8)
504                        self.sp_img[id]=img                             
505                               
506        #def spinner_sync       
507                       
508        def pulsate_check_sync(self,id,widget,profile):
509               
510               
511                if self.sync_threads[id]["thread"].is_alive():
512                        self.spinner_sync(id)
513                        widget.set_image(self.sp_img[id])
514                        widget.set_tooltip_text(_("Applying changes..."))       
515                        self.sp_cont[id]=self.sp_cont[id]+1
516                        return True
517               
518                else:
519                        self.profile_clicked.remove(profile)
520                        self.current_status[profile]=self.result_sync_threads[id]["status_info"]["status"]     
521                        if self.result_sync_threads[id]["status_mod"]["result"]==False:
522                                if self.result_sync_threads[id]["status_mod"]["code"]==8:
523                                        message=_("Error: Unable to connect with google")       
524                                else:
525                                        status=self.current_status[profile]
526                                        if status:
527                                                action=_("dismount")
528                                        else:
529                                                action=_("mount")       
530                                        message=_("Error: Unable to ") + action + " " 
531                        else:
532                                if self.result_sync_threads[id]["status_mod"]["code"]==9:
533                                        message=_("Status updated. Now you can change it")
534                                else:
535                                        message=_("Changes applied successfully")
536                       
537                        self.show_message(profile + ": " + message)
538                       
539                        info=self.item_status_info(self.result_sync_threads[id]["status_info"])
540                       
541                        for item in self.menu.get_children():
542                                        if item.size:
543                                                if item.profile==profile:
544                                                        item.set_label(info["used_size"])
545                               
546                        widget.set_tooltip_text(info["tooltip"])
547                        widget.set_image(info["img"])   
548                        self.sync_threads.pop(id)
549                        self.sp_cont.pop(id)
550                        self.sp_img.pop(id)
551                        self.result_sync_threads.pop(id)
552               
553                return False
554
555        #def pulsate_check_sync
556                       
557       
558        def     check_sync(self,id,profile):
559               
560                mountpoint=self.profiles_info[profile]["mountpoint"]
561
562                current_status=self.current_status[profile]
563               
564                self.result_sync_threads[id]["status_mod"],self.result_sync_threads[id]["status_info"]=self.LliurexGoogleDriveManager.sync_profile(profile,mountpoint,current_status)
565
566
567                #self.result_connect_threads[id]["value"]=self.LliurexGoogleDriveManager.check_google_connection()
568
569        #def check_sync
570       
571        def open_folder(self,widget,profile):
572
573               
574                mountpoint=self.profiles_info[profile]["mountpoint"]
575                cmd="caja " + mountpoint.encode("utf-8")
576
577                os.system(cmd) 
578
579        #def open_folder
580
581        def refresh_cache_clicked (self,widget,profile):
582
583                message=self.refresh_cache_command(profile)
584               
585                message=message.decode("UTF-8")
586
587                time.sleep(0.5)
588                self.show_message(profile + ": " + message)     
589
590        #def refresh_cache_menu
591
592        def refresh_cache_command(self,profile):
593
594                profile=profile.encode("utf-8")
595
596                try:
597                        cmd="google-drive-ocamlfuse -cc -label %s"%profile
598                        os.system(cmd)
599                        message=_("Cache updated successfully")
600                               
601                except Exception as e:
602                        message=_("An error occurred updating the cache. Try again")
603
604                return message 
605
606        #def refresh_cache_command     
607
608        def open_gui(self,widget):
609               
610                if not os.path.exists(self.lock_gui):
611                        cmd='/usr/bin/lliurex-gdrive' +"&" 
612                        os.system(cmd)
613
614        #def open_gui
615               
616        def item_status_info(self,status_info):
617       
618                size=status_info["size"]
619                used=status_info["used"]
620
621                if status_info['status']==None:
622                        img=Gtk.Image.new_from_file(MOUNT_WARNING_IMAGE)
623                        tooltip=_("Without connection. Clicked to update")
624                        used_size=_("Used: not available")
625               
626                elif status_info["status"]:
627                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
628                        tooltip=_("Mounted. Clicked to dismount now")
629                        used_size=_("Used: %s of %s")%(used,size)
630               
631                else:
632                        img=Gtk.Image.new_from_file(MOUNT_OFF_IMAGE)
633                        tooltip=_("Dismounted. Clicked to mount now")
634                        used_size=_("Used: not available")     
635
636                return {"img":img ,"tooltip":tooltip, "used_size":used_size}   
637
638        #def item_status_info                   
639
640        def check_status(self):
641               
642                if not self.checking_status:
643                        self.checking_status=True
644                        self.init_connect_thread()
645                        GLib.timeout_add(100,self.get_status_info,id)
646
647                return True
648               
649               
650        #def check_status
651       
652        def get_status_info(self,id):
653               
654                if self.check_connect_t.is_alive():
655                        return True
656               
657                else:   
658                        self.update_files=[]
659                        self.checking_status=False
660                        #self.connect_threads.pop(id)
661                        for profile in self.profiles_info:
662                                if self.connection:
663                                        self.refresh_cache_command(profile)
664                                        mountpoint=self.profiles_info[profile]["mountpoint"]
665                                        status_info=self.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
666                                        self.update_folders_info(profile,mountpoint)
667
668                                else:
669                                        status_info={}
670                                        status_info['status']=None
671                                        status_info['size']=0
672                                        status_info['used']=0
673                                       
674                                info=self.item_status_info(status_info)
675                                self.current_status[profile]=status_info["status"]
676                                                               
677                                for item in self.menu.get_children():
678                                        if item.profile==profile:
679                                                if item.size:
680                                                        item.set_label(info["used_size"])
681                                                if item.status:
682                                                        item.set_tooltip_text(info["tooltip"])
683                                                        item.set_image(info["img"])
684               
685                #self.result_connect_threads.pop(id)           
686                self.notify_changes()
687                return False   
688
689        #def get_status_info   
690                                       
691        def check_connect(self):
692               
693                self.connection=self.LliurexGoogleDriveManager.check_google_connection()
694
695        #def check_connect     
696
697        def update_folders_info(self,profile,mountpoint):
698
699                self.folders_info={}
700                self.folders_info['profile']=profile
701                self.files=set()
702               
703                self.controlDirectory(mountpoint)
704                self.folders_info['files']=self.files
705                self.update_files.append(self.folders_info)     
706
707        #def update_folders_info       
708                               
709
710        def notify_changes(self):
711
712
713                if self.init_files!=self.update_files:
714                        toInfo=self.remove_local_changes()
715
716                        for item in toInfo:
717                                numFiles_up=0
718                                numFiles_rm=0
719                                numFiles_add=0
720                                p=item['profile']
721                                if 'files_changes' in item:
722                                        numFiles_up=len(item['files_changes'])
723                               
724                                if 'files_delete' in item:     
725                                        numFiles_rm=len(item['files_delete'])
726                               
727                                if 'files_add' in item: 
728                                        numFiles_add=len(item['files_add'])
729                               
730                                if numFiles_up>0 or numFiles_rm>0 or numFiles_add>0:
731                                        message1=_('Changes in last 15 minutes in ')+p.encode("utf-8")+':\n'
732                                        message_up=""
733                                        message_rm=""
734                                        message_add=""         
735                                        if numFiles_up>0:
736                                                message_up=_("-Files updated: ")
737                                                for i in self.notifications_list:
738                                                        if i['profile']==p:
739                                                                for element in item['files_changes']:
740                                                                        i['notifications'].append(element)
741                                                if numFiles_up==1:
742                                                        for element in item['files_changes']:
743                                                                file=os.path.basename(element.split(":__")[0])
744                                                                file_split=os.path.splitext(file)
745                                                                if file_split[1]==".desktop":
746                                                                        file=file_split[0]
747                                                                message_up=message_up + file.encode("utf-8") +'\n'
748                                                                       
749                                                else:   
750                                                        message_up= message_up + str(numFiles_up) + '\n'
751
752                                        if numFiles_add>0:
753                                                message_add=_("-Files added: ")
754                                                for i in self.notifications_list:
755                                                        if i['profile']==p:
756                                                                for element in item['files_add']:
757                                                                        i['notifications'].append(element)
758                                                if numFiles_add==1:
759                                                        for element in item['files_add']:
760                                                                file=os.path.basename(element.split(":__")[0])
761                                                                file_split=os.path.splitext(file)
762                                                                if file_split[1]==".desktop":
763                                                                        file=file_split[0]
764                                                                message_add=message_add +file.encode("utf-8") +'\n'
765                                                else:
766                                                               
767                                                        message_add=message_add + str(numFiles_add) + '\n'
768
769                                        if numFiles_rm>0:
770                                                message_rm=_("-Files deleted: ")       
771                                                if numFiles_rm==1:
772                                                        for element in item['files_delete']:
773                                                                file=os.path.basename(element.split(":__")[0]) 
774                                                                file_split=os.path.splitext(file)
775                                                                if file_split[1]==".desktop":
776                                                                        file=file_split[0]
777                                                                message_rm=message_rm + file.encode("utf-8") +'\n'
778                                                else:           
779                                                        message_rm=message_rm +str(numFiles_rm)
780
781                                        self.show_message(message1 + message_add + message_up + message_rm)
782
783                self.init_files=copy.copy(self.update_files)
784                self.local_changes={}
785
786        #def notify_changes
787       
788        def remove_local_changes(self):
789
790                changes=self.detect_folder_changes()
791
792                changes_toNotify=[]
793               
794                if len(changes)>0:
795
796                        for item in changes:
797                                tmp_changes=[]
798                                tmp_deletes=[]
799                                tmp_add=[]
800                                to_info={}
801                                to_info['profile']=item['profile']
802
803                                if 'files_changes' in item:
804                                        #tmp_changes=item['files_changes']
805                                        tmp_changes=self.detect_previous_notifications(item)
806                                        toInfo_up=tmp_changes.copy()   
807                                if 'files_deletes' in item:
808                                        tmp_deletes=item['files_deletes']       
809                                        toInfo_rm=tmp_deletes.copy()
810
811                                if 'files_add' in item:
812                                        tmp_add=item['files_add']       
813                                        toInfo_add=tmp_add.copy()
814
815
816                                if len(self.local_changes)>0:
817                                        if len(tmp_changes)>0:
818                                                for item in tmp_changes:
819                                                        #file=item.keys()[0]
820                                                        file=item.split(":__")[0]
821                                                        data=item.split(":__")[1]
822                                                        for i in self.local_changes:
823                                                                if file==i:
824                                                                        data=datetime.datetime.strptime(data,'%Y-%m-%d %H:%M:%S')
825                                                                        if data<=self.local_changes[i]:
826                                                                                toInfo_up.remove(item)
827                                                to_info['files_changes']=toInfo_up                             
828                                        if len(tmp_deletes)>0:
829                                                for item in tmp_deletes:
830                                                        file=os.path.basename(item.split(":__")[0])
831                                                        file=os.path.splitext(file)[0]
832                                                        data=item.split(":__")[1]
833                                                        for i in self.local_changes:
834                                                                if file in i:
835                                                                        data=datetime.datetime.strptime(data,'%Y-%m-%d %H:%M:%S')
836                                                                        if data<=self.local_changes[i]:
837                                                                                toInfo_rm.remove(item)
838                                                to_info['files_delete']=toInfo_rm                                       
839
840                                        if len(tmp_add)>0:
841                                                for item in tmp_add:
842                                                        file=item.split(":__")[0]
843                                                        data=item.split(":__")[1]
844                                                        for i in self.local_changes:
845                                                                if file==i:
846                                                                        data=datetime.datetime.strptime(data,'%Y-%m-%d %H:%M:%S')
847                                                                        if data<=self.local_changes[i]:
848                                                                                toInfo_add.remove(item) 
849                                                to_info['files_add']=toInfo_add
850                                else:
851                                        to_info['files_changes']=tmp_changes
852                                        to_info['files_delete']=tmp_deletes
853                                        to_info['files_add']=tmp_add           
854
855                                changes_toNotify.append(to_info)
856
857                return changes_toNotify
858
859        #def remove_local_changes
860
861
862        def detect_folder_changes(self):
863
864                changes=[]
865                               
866               
867                for item in self.update_files:
868                        info_changes={}
869                        info_changes['profile']=item['profile']
870                        final_files=item['files']
871
872                        for item in self.init_files:
873                                profile_init=item['profile']
874                                original_files=item['files']
875                                if len(original_files)>0:
876                                        if len(final_files)>0:
877                                                if info_changes['profile']==profile_init:
878                                                        diff_changes=final_files.difference(original_files)
879                                                        diff_deletes=original_files.difference(final_files)
880                                                       
881                                                        if len(diff_changes)>0:
882                                                                changes.append(info_changes)
883
884                                                                if len(diff_deletes)>0: 
885                                                                                tmp_del=diff_deletes.copy()
886                                                                                tmp_add=diff_changes.copy()
887                                                                                for item in diff_deletes:
888                                                                                        file_d=item.split(":__")[0]
889                                                                                        for element in diff_changes:
890                                                                                                file_c=element.split(":__")[0]
891                                                                                                if file_d == file_c:
892                                                                                                        tmp_del.remove(item)
893                                                                                                        tmp_add.remove(element)
894
895                                                                                if len(tmp_del)>0:
896                                                                                        info_changes['files_deletes']=tmp_del
897
898                                                                                if len(tmp_add)>0:
899                                                                                        info_changes['files_add']=tmp_add
900                                                                                        tmp_up=diff_changes.difference(tmp_add)
901                                                                                        info_changes['files_changes']=tmp_up
902                                                                                else:
903                                                                                        info_changes['files_changes']=diff_changes     
904                                                                                               
905                                                                else:
906                                                                        info_changes['files_add']=diff_changes                 
907                                                        else:
908                                                                if len(original_files)>len(final_files) and len(diff_deletes)>0:
909                                                                        info_changes['files_deletes']=diff_deletes
910                                                                        changes.append(info_changes)
911                               
912                                                       
913                return changes 
914
915        #def detect_folder_changes                                                                     
916       
917
918        def detect_previous_notifications(self,item):
919
920                changes=item['files_changes']
921                toInfo_up=changes.copy()
922                for element in self.notifications_list:
923                        if item['profile']==element['profile']:
924                                for f in changes:
925                                        file_changed=f.split(":__")[0]
926                                        data_changed=f.split(":__")[1]
927                                        data_changed=datetime.datetime.strptime(data_changed,'%Y-%m-%d %H:%M:%S')
928                                        for j in element['notifications']:
929                                                file_notified=j.split(":__")[0]
930                                                data_notified=j.split(":__")[1]
931                                                data_notified=datetime.datetime.strptime(data_notified,'%Y-%m-%d %H:%M:%S')
932                                                if file_changed==file_notified:
933                                                        diff=(data_changed-data_notified).seconds
934                                                        if int(diff)<6:
935                                                                toInfo_up.remove(f)
936
937
938                return toInfo_up       
939
940        #def detect_previous_notifications                                             
941
942        def show_message(self,message):
943                notify2.init("llxgdrive")
944                n=notify2.Notification("Lliurex-GDrive",message,"gdrive")
945                n.show()
946                return
947
948        #def show_message       
949                               
950       
951        def cleanIndicatorLock(self):
952
953                if os.path.exists(self.lock_indicator):
954                        os.remove(self.lock_indicator)
955
956        #def cleanIndicatorLock                 
957       
958        def quit(self,widget):
959
960                self.cleanIndicatorLock()
961                Gtk.main_quit() 
962
963        #def quit       
964
965       
966#class LliurexGdriveIndicator
967
968if __name__=="__main__":
969       
970        lliurexgdrive=LliurexGdriveIndicator("gdrive")
971        GObject.threads_init()
972        Gtk.main()
973       
Note: See TracBrowser for help on using the repository browser.