Changeset 6435


Ignore:
Timestamp:
Dec 6, 2017, 5:22:44 PM (2 years ago)
Author:
jrpelegrina
Message:

Fix file

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lliurex-gdrive/trunk/WIP_files/lliurexGdriveIndicator

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