source: lliurex-gdrive/trunk/WIP_files/lliurexGdriveIndicator @ 6432

Last change on this file since 6432 was 6432, checked in by jrpelegrina, 2 years ago

WIP in notify changes

  • Property svn:executable set to *
File size: 22.4 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 lliurex.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
51formato = '%d-%m-%y %H:%M:%S'
52TIME_CHECK_STATUS=900000
53
54class LliurexGdriveIndicator:
55
56        WATCH_DIR=os.path.expanduser("~/.config/lliurex-google-drive-profiles/")
57       
58        def __init__(self,icon_name):
59               
60                self.lock_gui=os.path.expanduser(LOCK_GUI)
61                self.lock_indicator=os.path.expanduser(LOCK_INDICATOR)         
62
63                self.LliurexGoogleDriveManager=lliurex.lliurexgdrive.LliurexGoogleDriveManager()
64                self.app_indicator=appindicator.Indicator.new("lliurex-gdrive",icon_name,appindicator.IndicatorCategory.APPLICATION_STATUS)
65                self.app_indicator.set_status(appindicator.IndicatorStatus.ACTIVE)
66                self.menu = Gtk.Menu()
67               
68                self.menu.add_events(Gdk.EventMask.ALL_EVENTS_MASK)
69                self.app_indicator.set_menu(self.menu)
70               
71                self.profiles_info=self.LliurexGoogleDriveManager.profiles_config.copy()
72                self.current_status={}
73                self.blacklist=['.Trash','.Trash-1000']
74                self.init_files=[]
75                self.update_files=[]
76                self.local_changes={}
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                t=threading.Thread(target=self._inotify)
135                t.daemon=True
136                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                class Process_handler(ProcessEvent):
148                               
149                        def __init__(self,main):
150                               
151                                self.main=main
152                               
153                        def process_IN_CLOSE_WRITE(self,event):
154
155                                self.main.update_info()
156                                self.main.initial_connection=True
157
158                                if os.path.expanduser(event.pathname)==os.path.join(LliurexGdriveIndicator.WATCH_DIR,"configProfiles"):
159                                       
160                                        for profile in self.main.update_profiles:
161                                                mountpoint_new=self.main.update_profiles[profile]["mountpoint"]
162                                                gdriveFolder_new=self.main.update_profiles[profile]["gdrive_folder"]
163                                                if not profile in self.main.profiles_info:
164                                                        self.main.add_menu_item(profile,mountpoint_new)
165                                                        wdd=wm.add_watch(mountpoint_new,mask,rec=True)
166                                                else:
167                                                        mountpoint_old=self.main.profiles_info[profile]["mountpoint"]
168                                                        gdriveFolder_old=self.main.profiles_info[profile]["gdrive_folder"]
169                                                        if (mountpoint_new != mountpoint_old) or (gdriveFolder_new != gdriveFolder_old): 
170                                                                self.main.remove_folder_info(profile)
171                                                                ide=wm.get_wd(mountpoint_old)
172                                                                wdd=wm.rm_watch(ide,rec=True)
173                                                                self.main.init_folders_info(profile,mountpoint_new)
174                                                                wdd=wm.add_watch(mountpoint_new,mask,rec=True)
175
176                                        profile_rm=""
177                                        for item in self.main.menu.get_children():
178                                                if item.profile !="":
179                                                        if not item.profile in self.main.update_profiles:
180                                                                self.main.menu.remove(item)
181                                                                profile_rm=item.profile
182
183                                        if profile_rm !="":
184                                                mountpoint=self.main.profiles_info[profile_rm]["mountpoint"]
185                                                self.main.remove_folder_info(profile_rm)
186                                                ide=wm.get_wd(mountpoint)
187                                                wdd=wm.rm_watch(ide,rec=True)                           
188                                                               
189
190                                        self.main.profiles_info=self.main.update_profiles.copy()
191                                        self.main.menu.show_all()
192
193                                else:
194                                        if 'mountToken' in os.path.basename(event.pathname):
195                                                        tmp_profile=os.path.basename(event.pathname).split("__")[0]
196                                                        print tmp_profile
197                                                        for item in self.main.profiles_info:
198                                                                if item==tmp_profile:
199                                                                        tmp_mountpoint=self.main.profiles_info[item]["mountpoint"]
200                                                                        if os.path.exists(event.pathname):
201                                                                                self.main.remove_folder_info(item)
202                                                                                ide=wm.get_wd(tmp_mountpoint)
203                                                                                wdd=wm.rm_watch(ide,rec=True)
204                                                                                self.main.init_folders_info(item,tmp_mountpoint)
205                                                                                wdd=wm.add_watch(tmp_mountpoint,mask,rec=True)
206                                                                        else:
207                                                                                self.main.remove_folder_info(item)
208                                                                                ide=wm.get_wd(tmp_mountpoint)
209                                                                                wdd=wm.rm_watch(ide,rec=True)   
210
211                                        else:                           
212                                                time.sleep(2)
213                                                t=join(event.path,event.name)
214                                                print t
215                                                if isfile(t):
216                                                        try:
217                                                               
218                                                                estado=os.stat(t)
219                                                        except Exception as e:
220                                                                print str(e)
221                                                                t=t.split('trashinfo')
222                                                                t=t[0]+'trashinfo'
223                                                                estado=os.stat(t)
224                                                               
225                                                                               
226                                                        acceso=datetime.datetime.fromtimestamp(estado.st_mtime)
227                                                        self.main.local_changes[t]=acceso
228                                                                               
229               
230                notifier=Notifier(wm,Process_handler(self))
231                wdd=wm.add_watch(LliurexGdriveIndicator.WATCH_DIR,mask,rec=True)
232               
233                for profile in self.profiles_info:
234                        path=os.path.expanduser(self.profiles_info[profile]["mountpoint"])
235                        wdd=wm.add_watch(path,mask,rec=True)
236
237               
238                while True:
239                        try:
240                               
241                                notifier.process_events()
242                                if notifier.check_events():
243                                                notifier.read_events()
244
245                        except Exception as e:
246                                print str(e)
247                                notifier.stop()
248               
249                return False
250       
251        #def _inotify
252
253        def update_info(self):
254
255                f=open(self.LliurexGoogleDriveManager.config_file)
256
257                try:
258                        self.update_profiles=json.load(f)
259                except:
260                        self.update_profiles={}
261               
262                f.close()
263
264        #def update_info       
265       
266        def add_menu_item(self,profile,mountpoint):
267
268                if self.initial_connection:
269                        status_info=self.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
270                        info=self.item_status_info(status_info)
271                        self.current_status[profile]=status_info["status"]     
272                else:
273                        status_info={}
274                        status_info['status']=None
275                        status_info['size']=0
276                        status_info['used']=0
277                        info=self.item_status_info(status_info)
278                        self.current_status[profile]=None
279                               
280                label_item=profile     
281                item=Gtk.ImageMenuItem()
282                item.set_label(label_item)
283                item.set_image(info["img"])
284                item.set_tooltip_text(info["tooltip"])
285                item.profile=profile
286                item.size=False
287                item.status=True
288                item.set_always_show_image(True)
289                item.connect("activate",self.item_clicked,profile)
290                self.menu.insert(item,0)
291
292               
293                item=Gtk.MenuItem()
294                label_item=info["used_size"]
295                item.set_label(label_item)
296                item.profile=profile
297                item.size=True
298                item.status=False
299                self.menu.insert(item,1)
300
301                item=Gtk.MenuItem()
302                label_item=_("Open folder")
303                item.set_label(label_item)
304                item.connect("activate",self.open_folder,profile)
305                item.profile=profile
306                item.size=False
307                item.status=False
308                self.menu.insert(item,2)
309
310                item=Gtk.MenuItem()
311                label_item=_("Update cache")
312                item.set_label(label_item)
313                item.set_tooltip_text(_("Click if do not see all the files in the Google Drive account"))
314                item.connect("activate",self.refresh_cache,profile)
315                item.profile=profile
316                item.size=False
317                item.status=False
318                self.menu.insert(item,3)
319
320                item=Gtk.SeparatorMenuItem()
321                item.profile=profile
322                item.size=False
323                item.status=False
324                self.menu.insert(item,4)
325                self.init_folders_info(profile,mountpoint)
326
327        #def add_menu_item     
328
329
330        def populate_menu(self,empty=True):
331               
332               
333                if empty:
334                        for c in self.menu.get_children():
335                                self.menu.remove(c)
336               
337               
338                for profile in self.profiles_info:
339                        mountpoint=self.profiles_info[profile]["mountpoint"]
340                        self.add_menu_item(profile,mountpoint)
341                       
342                       
343                item=Gtk.ImageMenuItem()
344                label_item=_("Open Lliurex GDrive")
345                item.set_label(label_item)
346                img=Gtk.Image()
347                img.set_from_stock(Gtk.STOCK_PREFERENCES,Gtk.IconSize.MENU)
348                item.set_image(img)
349                item.set_always_show_image(True)
350                item.connect("activate",self.open_gui)
351                item.profile=""
352                item.size=False
353                item.status=False
354                self.menu.append(item)
355
356                item=Gtk.ImageMenuItem()
357                img=Gtk.Image()
358                img.set_from_stock(Gtk.STOCK_CLOSE,Gtk.IconSize.MENU)
359                item.set_image(img)
360                item.set_always_show_image(True)
361                label_item=_("Close")
362                item.set_label(label_item)
363                item.connect("activate",self.quit)
364                item.profile=""
365                item.size=False
366                item.status=False
367                self.menu.append(item)
368
369
370                self.menu.show_all()
371               
372               
373        #def populate_menu
374       
375        def init_folders_info(self,profile,mountpoint):
376
377                self.folders_info={}
378                self.folders_info['profile']=profile
379                self.files=set()
380                self.controlDirectory(mountpoint)
381                self.folders_info['files']=self.files
382                self.init_files.append(self.folders_info)
383                       
384        #def init_folders_info                         
385
386
387        def controlDirectory(self,path):
388               
389               
390                for item in listdir(path):
391                        if item not in self.blacklist:
392                               
393                                t=join(path,item)
394
395                                if isfile(t):
396                                       
397                                        compartido=False
398                                        estado=os.stat(t)
399                                        acceso=datetime.datetime.fromtimestamp(estado.st_mtime)
400                                        last_update=acceso.strftime(formato)
401                                        tmp=t+":__"+str(acceso)
402                                       
403                                        self.files.add(tmp)
404                                else:
405                                        if isdir(t):
406                                                self.controlDirectory(t)       
407
408        #def controlDirectory                                   
409                                               
410        def remove_folder_info(self,profile):
411
412                i=0
413                for item in self.init_files:
414                        print item
415                        if profile ==item["profile"]:
416                                print "borrado OK"
417                                self.init_files.pop(i)
418                        i=i+1   
419
420        #def remove_folder_info         
421       
422
423        def item_clicked(self,widget,profile):
424       
425                if profile not in self.profile_clicked:
426                        self.profile_clicked.append(profile)
427                        id=self.generate_sync_threads(profile)
428                        self.sp_cont[id]=0
429                        self.sp_img[id]=Gtk.Image.new_from_file(SP1)
430                        GLib.timeout_add(100,self.pulsate_check_sync,id,widget,profile)
431                       
432               
433        #def item_clicked
434
435        def spinner_sync(self,id):
436       
437                if self.sp_cont[id]>80:
438                        self.sp_cont[id]=0
439                       
440                if self.sp_cont[id]==0:
441                        img=Gtk.Image.new_from_file(SP1)
442                        self.sp_img[id]=img
443                elif self.sp_cont[id]==10:
444                        img=Gtk.Image.new_from_file(SP2)
445                        self.sp_img[id]=img                     
446                elif self.sp_cont[id]==20:
447                        img=Gtk.Image.new_from_file(SP3)
448                        self.sp_img[id]=img
449                elif self.sp_cont[id]==30:
450                        img=Gtk.Image.new_from_file(SP4)
451                        self.sp_img[id]=img
452                elif self.sp_cont[id]==40:
453                        img=Gtk.Image.new_from_file(SP5)
454                        self.sp_img[id]=img     
455                elif self.sp_cont[id]==50:
456                        img=Gtk.Image.new_from_file(SP6)
457                        self.sp_img[id]=img     
458                elif self.sp_cont[id]==60:
459                        img=Gtk.Image.new_from_file(SP7)
460                        self.sp_img[id]=img     
461                elif self.sp_cont[id]==70:
462                        img=Gtk.Image.new_from_file(SP8)
463                        self.sp_img[id]=img                             
464                               
465        #def spinner_sync       
466                       
467        def pulsate_check_sync(self,id,widget,profile):
468               
469               
470                if self.sync_threads[id]["thread"].is_alive():
471                        self.spinner_sync(id)
472                        widget.set_image(self.sp_img[id])
473                        widget.set_tooltip_text(_("Applying changes..."))       
474                        self.sp_cont[id]=self.sp_cont[id]+1
475                        return True
476               
477                else:
478                        self.profile_clicked.remove(profile)
479                        self.current_status[profile]=self.result_sync_threads[id]["status_info"]["status"]     
480                        if self.result_sync_threads[id]["status_mod"]["result"]==False:
481                                if self.result_sync_threads[id]["status_mod"]["code"]==8:
482                                        message=_("Error: Unable to connect with google")       
483                                else:
484                                        status=self.current_status[profile]
485                                        if status:
486                                                action=_("dismount")
487                                        else:
488                                                action=_("mount")       
489                                        message=_("Error: Unable to ") + action + " " 
490                        else:
491                                if self.result_sync_threads[id]["status_mod"]["code"]==9:
492                                        message=_("Status updated. Now you can change it")
493                                else:
494                                        message=_("Changes applied successfully")
495                       
496                        self.show_message(profile + ": " + message)
497                       
498                        info=self.item_status_info(self.result_sync_threads[id]["status_info"])
499                       
500                        for item in self.menu.get_children():
501                                        if item.size:
502                                                if item.profile==profile:
503                                                        item.set_label(info["used_size"])
504                               
505                        widget.set_tooltip_text(info["tooltip"])
506                        widget.set_image(info["img"])   
507                        self.sync_threads.pop(id)
508                        self.sp_cont.pop(id)
509                        self.sp_img.pop(id)
510                        self.result_sync_threads.pop(id)
511               
512                return False
513
514        #def pulsate_check_sync
515                       
516       
517        def     check_sync(self,id,profile):
518               
519                mountpoint=self.profiles_info[profile]["mountpoint"]
520
521                current_status=self.current_status[profile]
522               
523                self.result_sync_threads[id]["status_mod"],self.result_sync_threads[id]["status_info"]=self.LliurexGoogleDriveManager.sync_profile(profile,mountpoint,current_status)
524
525
526                #self.result_connect_threads[id]["value"]=self.LliurexGoogleDriveManager.check_google_connection()
527
528        #def check_sync
529       
530        def open_folder(self,widget,profile):
531
532               
533                mountpoint=self.profiles_info[profile]["mountpoint"]
534                cmd="caja " + mountpoint.encode("utf-8")
535
536                os.system(cmd) 
537
538        #def open_folder
539
540        def refresh_cache (self,widget,profile):
541
542                try:
543                        cmd="google-drive-ocamlfuse -cc -label %s"%profile
544                        os.system(cmd)
545                        message=_("Cache updated successfully")
546                               
547                except Exception as e:
548                        message=_("An error occurred updating the cache. Try again")
549               
550                message=message.decode("UTF-8")
551
552                time.sleep(0.5)
553                self.show_message(profile + ": " + message)     
554
555        #def refresh_cache     
556
557        def open_gui(self,widget):
558               
559                if not os.path.exists(self.lock_gui):
560                        cmd='/usr/bin/lliurex-gdrive' +"&" 
561                        os.system(cmd)
562
563        #def open_gui
564               
565        def item_status_info(self,status_info):
566       
567                size=status_info["size"]
568                used=status_info["used"]
569
570                if status_info['status']==None:
571                        img=Gtk.Image.new_from_file(MOUNT_WARNING_IMAGE)
572                        tooltip=_("Without connection. Clicked to update")
573                        used_size=_("Used: not available")
574               
575                elif    status_info["status"]:
576                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
577                        tooltip=_("Mounted. Clicked to dismount now")
578                        used_size=_("Used: %s of %s")%(used,size)
579               
580                else:
581                        img=Gtk.Image.new_from_file(MOUNT_OFF_IMAGE)
582                        tooltip=_("Dismounted. Clicked to mount now")
583                        used_size=_("Used: not available")     
584
585                return {"img":img ,"tooltip":tooltip, "used_size":used_size}   
586
587        #def item_status_info                   
588
589        def check_status(self):
590               
591                if not self.checking_status:
592                        self.checking_status=True
593                        self.init_connect_thread()
594                        GLib.timeout_add(100,self.get_status_info,id)
595
596                return True
597               
598               
599        #def check_status
600       
601        def get_status_info(self,id):
602               
603                if self.check_connect_t.is_alive():
604                        return True
605               
606                else:   
607                        self.checking_status=False
608                        #self.connect_threads.pop(id)
609                        for profile in self.profiles_info:
610                                if self.connection:
611                                        cmd="google-drive-ocamlfuse -cc -label %s"%profile
612                                        os.system(cmd)
613                                        mountpoint=self.profiles_info[profile]["mountpoint"]
614                                        status_info=self.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
615                                        self.update_folders_info(profile,mountpoint)
616
617                                else:
618                                        status_info={}
619                                        status_info['status']=None
620                                        status_info['size']=0
621                                        status_info['used']=0
622                                       
623                                info=self.item_status_info(status_info)
624                                self.current_status[profile]=status_info["status"]
625                                                               
626                                for item in self.menu.get_children():
627                                        if item.profile==profile:
628                                                if item.size:
629                                                        item.set_label(info["used_size"])
630                                                if item.status:
631                                                        item.set_tooltip_text(info["tooltip"])
632                                                        item.set_image(info["img"])
633               
634                #self.result_connect_threads.pop(id)           
635                self.notify_changes()
636                return False   
637
638        #def get_status_info   
639                                       
640        def check_connect(self):
641               
642                self.connection=self.LliurexGoogleDriveManager.check_google_connection()
643
644        #def check_connect     
645
646       
647        def update_folders_info(self,profile,mountpoint):
648
649                self.folders_info={}
650                self.folders_info['profile']=profile
651                self.files=set()
652                self.controlDirectory(mountpoint)
653                self.folders_info['files']=self.files
654                self.update_files.append(self.folders_info)     
655
656        #def update_folders_info       
657
658        def notify_changes(self):
659
660
661                if self.init_files!=self.update_files:
662                        toInfo=self.remove_local_changes()
663                       
664                        for item in toInfo:
665                                numFiles_up=0
666                                numFiles_rm=0
667                                numFiles_add=0
668                                p=item['profile']
669                                if 'files_changes' in item:
670                                        numFiles_up=len(item['files_changes'])
671                                if 'files_delete' in item:     
672                                        numFiles_rm=len(item['files_delete'])
673                                if 'files_add' in item: 
674                                        numFiles_add=len(item['files_add'])
675                                if numFiles_up>0 or numFiles_rm>0 or numFiles_add>0:
676                                        message1=_(': changes in last 15 minutes:\n')
677                                        message_up=""
678                                        message_rm=""
679                                        message_add=""         
680                                        if numFiles_up>0:
681                                                message_up=_("-Files updated: ")
682                                                if numFiles_up==1:
683                                                        for element in item['files_changes']:
684                                                                file=os.path.basename(element.split(":__")[0])
685                                                                file_extension=os.path.splitex(file)
686                                                                if file_extension[1]==".desktop":
687                                                                        file=file_extension[0]
688
689                                                                message_up=message_up + file +'\n'
690                               
691                                                else:   
692                                                        message_up=message_up+str(numFiles_up) + '\n'
693
694                                        if numFiles_add>0:
695                                                message_add=_("-Files added: ")
696                                                if numFiles_add==1:
697                                                                for element in item['files_add']:
698                                                                        file=os.path.basename(element.split(":__")[0])
699                                                                        file_extension=os.path.splitex(file)
700                                                                        if file_extension[1]==".desktop":
701                                                                                file=file_extension[0]
702                                                                        message_add=message_add + file +'\n'
703                                                        else:
704                                                                message_add=message_add+str(numFiles_add) + '\n'
705
706                                        if numFiles_rm>0:       
707                                                message_rm=_("-Files deleted: ")
708                                                if numFiles_rm==1:
709                                                        for element in item['files_delete']:
710                                                                file=os.path.basename(element.split(":__")[0]) 
711                                                                file_extension=os.path.splitex(file)
712                                                                if file_extension[1]==".desktop":
713                                                                        file=file_extension[0]
714                                                                message_rm= message_rm + file +'\n'
715                                                else:           
716                                                        message_rm= message_rm+str(numFiles_rm)
717                                                        print message_rm
718                                       
719                                        self.show_message(p + message1 + message_add + message_up + message_rm)
720
721                self.init_files=copy.copy(self.update_files)
722                self.local_changes={}
723
724        def remove_local_changes(self):
725
726        changes=self.detect_changes()
727        changes_toNotify=[]
728
729        if len(changes)>0:
730                for item in changes:
731                        tmp_changes=[]
732                        tmp_deletes=[]
733                        tmp_add=[]
734                        to_info={}
735                        to_info['profile']=item['profile']
736
737                        if 'files_changes' in item:
738                                tmp_changes=item['files_changes']
739                                toInfo_up=tmp_changes.copy()
740                        if 'files_deletes' in item:
741                                tmp_deletes=item['files_deletes']       
742                                toInfo_rm=tmp_deletes.copy()
743                        if 'files_add' in item:
744                                tmp_add=item['files_add']       
745                                toInfo_add=tmp_add.copy()
746
747                        if len(self.local_changes)>0:
748                                if len(tmp_changes)>0:
749                                        for item in tmp_changes:
750                                                #file=item.keys()[0]
751                                                file=item.split(":__")[0]
752                                                data=item.split(":__")[1]
753                                                for i in self.local_changes:
754                                                        if file==i:
755                                                                data=datetime.datetime.strptime(data,'%Y-%m-%d %H:%M:%S')
756                                                                if data<=self.local_changes[i]:
757                                                                        toInfo_up.remove(item)
758                                        to_info['files_changes']=toInfo_up                             
759                                if len(tmp_deletes)>0:
760                                        for item in tmp_deletes:
761                                                file=os.path.basename(item.split(":__")[0])
762                                                file=os.path.splitext(file)[0]
763                                                data=item.split(":__")[1]
764                                                for i in self.local_changes:
765                                                        print i
766                                                        if file in i:
767                                                                data=datetime.datetime.strptime(data,'%Y-%m-%d %H:%M:%S')
768                                                                if data<=self.local_changes[i]:
769                                                                        toInfo_rm.remove(item)
770                                        to_info['files_delete']=toInfo_rm                                       
771
772                                if len(tmp_add)>0:
773                                        for item in tmp_add:
774                                                file=item.split(":__")[0]
775                                                data=item.split(":__")[1]
776                                                for i in self.local_changes:
777                                                        if file==i:
778                                                                data=datetime.datetime.strptime(data,'%Y-%m-%d %H:%M:%S')
779                                                                if data<=self.local_changes[i]:
780                                                                        toInfo_add.remove(item) 
781                                        to_info['files_add']=toInfo_add
782                        else:
783                                to_info['files_changes']=tmp_changes
784                                to_info['files_delete']=tmp_deletes
785                                to_info['files_add']=tmp_add           
786
787                        changes_toNotify.append(to_info)
788
789        return changes_toNotify
790
791        #remove_local_changes
792
793        def detect_changes(self):
794
795                changes=[]
796                               
797               
798                for item in self.update_files:
799                        info_changes={}
800                        info_changes['profile']=item['profile']
801                        final_files=item['files']
802
803                        for item in self.init_files:
804                                profile_init=item['profile']
805                                original_files=item['files']
806                                if len(original_files)>0:
807                                        if len(final_files)>0:
808                                                if info_changes['profile']==profile_init:
809                                                        diff_changes=final_files.difference(original_files)
810                                                        diff_deletes=original_files.difference(final_files)
811                                                        if len(diff_changes)>0:
812                                                                changes.append(info_changes)
813                                                                if len(diff_deletes)>0: 
814                                                                                tmp_del=diff_deletes.copy()
815                                                                                tmp_add=diff_changes.copy()
816                                                                                for item in diff_deletes:
817                                                                                        file_d=item.split(":__")[0]
818                                                                                        for element in diff_changes:
819                                                                                                file_c=element.split(":__")[0]
820                                                                                                if file_d == file_c:
821                                                                                                        tmp_del.remove(item)
822                                                                                                        tmp_add.remove(element)
823                                                                                if len(tmp_del)>0:
824                                                                                        info_changes['files_deletes']=tmp_del
825
826                                                                                if len(tmp_add)>0:
827                                                                                        info_changes['files_add']=tmp_add
828                                                                                        tmp_up=diff_changes.difference(tmp_add)
829                                                                                        info_changes['files_changes']=tmp_up
830                                                                                else:
831                                                                                        info_changes['files_changes']=diff_changes     
832                                                                                               
833                                                                else:
834                                                                        info_changes['files_add']=diff_changes                 
835                                                        else:
836                                                                if len(original_files)>len(final_files) and len(diff_deletes)>0:
837                                                                        info_changes['files_deletes']=diff_deletes
838                                                                        changes.append(info_changes)
839                                                       
840                return changes                                 
841
842        #def detect_changes     
843
844       
845        def show_message(self,message):
846                notify2.init("test")
847                n=notify2.Notification("Lliurex-GDrive",message,"gdrive")
848                n.show()
849                return
850
851        #def show_message       
852                               
853       
854        def cleanIndicatorLock(self):
855
856                if os.path.exists(self.lock_indicator):
857                        os.remove(self.lock_indicator)
858
859        #def cleanIndicatorLock                 
860       
861        def quit(self,widget):
862
863                self.cleanIndicatorLock()
864                Gtk.main_quit() 
865
866        #def quit       
867
868       
869#class LliurexGdriveIndicator
870
871if __name__=="__main__":
872       
873        lliurexgdrive=LliurexGdriveIndicator("gdrive")
874        GObject.threads_init()
875        Gtk.main()
876       
Note: See TracBrowser for help on using the repository browser.