731 lines
27 KiB
Python
Executable File
731 lines
27 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
#-*- coding: utf-8 -*-
|
|
# impra/index.py
|
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
|
#
|
|
# software : ImpraStorage <http://kirmah.sourceforge.net/>
|
|
# version : 1.01
|
|
# date : 2014
|
|
# licence : GPLv3.0 <http://www.gnu.org/licenses/>
|
|
# author : a-Sansara <[a-sansara]at[clochardprod]dot[net]>
|
|
# copyright : pluie.org <http://www.pluie.org/>
|
|
#
|
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
|
#
|
|
# This file is part of ImpraStorage.
|
|
#
|
|
# ImpraStorage is free software (free as in speech) : you can redistribute it
|
|
# and/or modify it under the terms of the GNU General Public License as
|
|
# published by the Free Software Foundation, either version 3 of the License,
|
|
# or (at your option) any later version.
|
|
#
|
|
# ImpraStorage is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
# more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with ImpraStorage. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
|
|
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
# ~~ module index ~~
|
|
|
|
from binascii import a2b_base64
|
|
from collections import Counter
|
|
from json import dumps as jdumps, loads as jloads
|
|
from re import split as regsplit, match as regmatch, compile as regcompile, search as regsearch
|
|
from psr.sys import Sys, Io, Const
|
|
from psr.log import Log
|
|
from psr.imap import BadLoginException
|
|
from impra.mail import MailBuilder
|
|
from kirmah.crypt import Kirmah, BadKeyException
|
|
|
|
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
# ~~ class ImpraIndex ~~
|
|
|
|
class ImpraIndex:
|
|
"""A representation of the index stored on the server"""
|
|
|
|
SEP_KEY_INTERN = '§'
|
|
"""Separator used for internal key such categories"""
|
|
UID = 0
|
|
""""""
|
|
HASH = 1
|
|
""""""
|
|
LABEL = 2
|
|
""""""
|
|
SIZE = 3
|
|
""""""
|
|
PARTS = 4
|
|
""""""
|
|
EXT = 5
|
|
""""""
|
|
USER = 6
|
|
""""""
|
|
CATG = 7
|
|
""""""
|
|
ACCOUNT = 8
|
|
""""""
|
|
KEY = 9
|
|
""""""
|
|
FILE_BINARY = 'b'
|
|
""""""
|
|
FILE_CRYPT = 'c'
|
|
""""""
|
|
COLS = ('ID','HASH','LABEL','SIZE','PART','TYPE','USER','CATEGORY','ACCOUNT','KEY')
|
|
""""""
|
|
KEY_EXT = '.key'
|
|
|
|
|
|
@Log(Const.LOG_BUILD)
|
|
def __init__(self, key, path, dicCategory={}, accountList={}, emit=False):
|
|
"""Initialize the index with rsa and encoded data
|
|
|
|
:Parameters:
|
|
`key` : str
|
|
appropriate key to decrypt/encrypt data
|
|
`mark` : str
|
|
appropriate mark to check correct key
|
|
`encdata` : str
|
|
initial content of the index encrypted with Kirmah Algorythm
|
|
and representing a dic index as json string
|
|
"""
|
|
self.pathPlain = path[:-len(Kirmah.EXT)]
|
|
self.keyPath = self.pathPlain+self.KEY_EXT
|
|
self.path = path
|
|
Io.set_data(self.keyPath, key)
|
|
self.dic = {}
|
|
self.acclist = accountList
|
|
encdata = Io.get_data(path, True) if Io.file_exists(path) else b''
|
|
|
|
if encdata == b'' :
|
|
self.dic = {}
|
|
self.id = 1
|
|
else :
|
|
self.dic = self.decrypt(path)
|
|
l = [self.dic[k][self.UID] for i, k in enumerate(self.dic) if not k.startswith(self.SEP_KEY_INTERN)]
|
|
if len(l) > 0 :
|
|
self.id = max(l)+1
|
|
else: self.id = 1
|
|
for k in dicCategory :
|
|
if k == 'users' :
|
|
for k1 in dicCategory[k]:
|
|
if self.SEP_KEY_INTERN+k in self.dic:
|
|
if k1 not in self.dic[self.SEP_KEY_INTERN+k]:
|
|
self.dic[self.SEP_KEY_INTERN+k][k1] = dicCategory[k][k1]
|
|
else :
|
|
if not self.SEP_KEY_INTERN+k in self.dic:
|
|
self.dic[self.SEP_KEY_INTERN+k] = dicCategory[k]
|
|
|
|
|
|
@Log()
|
|
def add(self, key, label, count, ext='', usr='', cat='', fhash='', size=0, account=''):
|
|
"""Add an entry to the index
|
|
"""
|
|
if self.get(fhash) == None :
|
|
self.dic[fhash] = (self.id, fhash, label, size, count, ext, usr, cat, account, key)
|
|
self.id +=1
|
|
return self.id-1
|
|
else :
|
|
Sys.dprint(label+' already exist')
|
|
|
|
|
|
@Log()
|
|
def addUser(self, nameFrom, hashName):
|
|
""""""
|
|
if not self.hasUser(hashName):
|
|
self.dic[self.SEP_KEY_INTERN+'users'][hashName] = nameFrom
|
|
|
|
|
|
@Log(Const.LOG_ALL)
|
|
def hasUser(self, hashName):
|
|
""""""
|
|
if not self.SEP_KEY_INTERN+'users' in self.dic:
|
|
self.dic[self.SEP_KEY_INTERN+'users'] = {}
|
|
return hashName in self.dic[self.SEP_KEY_INTERN+'users']
|
|
|
|
|
|
@Log(Const.LOG_ALL)
|
|
def getUser(self, hashName):
|
|
""""""
|
|
usrName = 'Anonymous'
|
|
if self.hasUser(hashName):
|
|
usrName = self.dic[self.SEP_KEY_INTERN+'users'][hashName]
|
|
return usrName
|
|
|
|
|
|
def getAllCatgs(self):
|
|
""""""
|
|
return self.dic[self.SEP_KEY_INTERN+'catg'].split(',') if self.SEP_KEY_INTERN+'catg' in self.dic else []
|
|
|
|
|
|
@Log()
|
|
def rem(self,label):
|
|
"""Remove the selected label from the index"""
|
|
self.dic.pop(label, None)
|
|
|
|
|
|
@Log()
|
|
def getAutoCatg(self,ext):
|
|
""""""
|
|
catg = 'none'
|
|
if regsearch('\.(jpg|jpeg|gif|png)',ext):
|
|
catg = 'images'
|
|
elif regsearch('\.(txt|doc|odt|csv|pdf)',ext):
|
|
catg = 'doc'
|
|
elif regsearch('\.(sh|py|c|cpp|h|php|bash)',ext):
|
|
catg = 'code'
|
|
elif regsearch('\.(mp4|avi|mpg|mpeg|flv|ogv)',ext):
|
|
catg = 'films'
|
|
elif regsearch('\.(mp3|ogg|flac)',ext):
|
|
catg = 'music'
|
|
elif regsearch('\.(zip|7z|tar|gz|rar|bz|xz|jar|bz2)',ext):
|
|
catg = 'archives'
|
|
return catg
|
|
|
|
|
|
@Log()
|
|
def isEmpty(self):
|
|
""""""
|
|
r = [k for i, k in enumerate(self.dic) if not k.startswith(self.SEP_KEY_INTERN)]
|
|
return len(r) == 0
|
|
|
|
|
|
@Log()
|
|
def getLabel(self, key):
|
|
"""Get label corresponding to key in the index
|
|
:Returns: `str`|None label
|
|
"""
|
|
value = ''
|
|
row = self.get(key)
|
|
if row is not None :
|
|
value = row[self.LABEL]
|
|
|
|
|
|
@Log()
|
|
def get(self, key):
|
|
"""Get the corresponding key in the index
|
|
:Returns: `tuple` row
|
|
"""
|
|
row = None
|
|
if key in self.dic : row = self.dic.get(key)
|
|
return row
|
|
|
|
|
|
@Log()
|
|
def edit(self, key, label=None, category=None):
|
|
"""Get the corresponding key in the index
|
|
:Returns: `tuple` row
|
|
"""
|
|
done = False
|
|
row = self.dic[key]
|
|
r = list(row)
|
|
if label != None :
|
|
try :
|
|
name, ext = Sys.getFileExt(label)
|
|
r[self.LABEL] = name
|
|
if ext is not '' :
|
|
r[self.EXT] = ext
|
|
except Exception as e :
|
|
r[self.LABEL] = label
|
|
if category != None :
|
|
r[self.CATG] = category
|
|
self.dic[key] = tuple(r)
|
|
done = row != self.dic[key]
|
|
return done
|
|
|
|
|
|
@Log()
|
|
def getById(self, sid):
|
|
"""Get the corresponding id in the index
|
|
:Returns: `str`|None key
|
|
"""
|
|
l = None
|
|
r = [k for i, k in enumerate(self.dic) if not k.startswith(self.SEP_KEY_INTERN) and self.dic[k][self.UID] == int(sid)]
|
|
if len(r)==1 : l = r[0]
|
|
return l
|
|
|
|
|
|
@Log()
|
|
def fixAccount(self,account):
|
|
""""""
|
|
r = [k for i, k in enumerate(self.dic) if not k.startswith(self.SEP_KEY_INTERN)]
|
|
for k in r:
|
|
t = list(self.dic[k])
|
|
if len(t)-1 < self.ACCOUNT:
|
|
t.append(account)
|
|
else:
|
|
t[self.ACCOUNT] = account
|
|
self.dic[k] = tuple(t)
|
|
|
|
|
|
@Log()
|
|
def getLightestAccount(self,l):
|
|
""""""
|
|
r = [k for i, k in enumerate(self.dic) if not k.startswith(self.SEP_KEY_INTERN)]
|
|
t = {}
|
|
for k in r:
|
|
if not self.dic[k][self.ACCOUNT] in t: t[self.dic[k][self.ACCOUNT]] = self.dic[k][self.SIZE]
|
|
else: t[self.dic[k][self.ACCOUNT]] += int(self.dic[k][self.SIZE])
|
|
profile = None
|
|
r = []
|
|
for a in l:
|
|
if not a in t :
|
|
profile = a
|
|
break
|
|
else :
|
|
r.append((t[a],a))
|
|
if profile is None :
|
|
d = sorted(r, reverse=False, key=lambda lst:lst[0])
|
|
profile = d[0][1]
|
|
return profile
|
|
|
|
|
|
@Log()
|
|
def fixDuplicateIds(self):
|
|
"""Get corresponding keys of duplicate ids in the index
|
|
:Returns: `str`|None key
|
|
"""
|
|
r = [k for i, k in enumerate(self.dic) if not k.startswith(self.SEP_KEY_INTERN)]
|
|
l = [(k,self.dic[k][self.UID]) for k in r]
|
|
l2 = [k[1] for k in l]
|
|
if len(l2)> 0 :
|
|
mxid = max(l2)
|
|
l3 = [x for x, y in Counter(l2).items() if y > 1]
|
|
d = [k[0] for k in l if any( k[1] == v for v in l3)]
|
|
for k in d:
|
|
mxid += 1
|
|
#mprint(self.dic[k])
|
|
t = list(self.dic[k])
|
|
t[self.UID] = mxid
|
|
#mprint(t)
|
|
self.dic[k] = tuple(t)
|
|
self.id = mxid+1
|
|
else:
|
|
self.id = 1
|
|
d = ()
|
|
return len(d)>0
|
|
|
|
|
|
@Log()
|
|
def getByLabel(self,label):
|
|
"""Get the corresponding label in the index
|
|
:Returns: `str`|None key
|
|
"""
|
|
l = None
|
|
r = [k for i, k in enumerate(self.dic) if not k.startswith(self.SEP_KEY_INTERN) and self.dic[k][self.LABEL] == label]
|
|
if len(r)==1: l = r[0]
|
|
return l
|
|
|
|
|
|
@Log()
|
|
def getByPattern(self,pattern):
|
|
"""Get ids corresponding to label matching the pattern in the index
|
|
:Returns: `[uid]`|None matchIds
|
|
"""
|
|
l = None
|
|
r = [ k for i,k in enumerate(self.dic) if not k.startswith(self.SEP_KEY_INTERN) and regsearch(pattern,self.dic[k][self.LABEL]) is not None ]
|
|
l = [self.dic[k][self.UID] for k in r]
|
|
return l
|
|
|
|
|
|
@Log()
|
|
def getByCategory(self,category):
|
|
"""Get ids corresponding to category
|
|
:Returns: `[uid]`|None matchIds
|
|
"""
|
|
l = None
|
|
r = [ k for i,k in enumerate(self.dic) if not k.startswith(self.SEP_KEY_INTERN) and regsearch(category,self.dic[k][self.CATG]) is not None ]
|
|
l = [self.dic[k][self.UID] for k in r]
|
|
return l
|
|
|
|
|
|
@Log()
|
|
def getByAccount(self,account):
|
|
"""Get ids corresponding to account
|
|
:Returns: `[uid]`|None matchIds
|
|
"""
|
|
l = None
|
|
r = [ k for i,k in enumerate(self.dic) if not k.startswith(self.SEP_KEY_INTERN) and account==self.dic[k][self.ACCOUNT] ]
|
|
l = [self.dic[k][self.UID] for k in r]
|
|
return l
|
|
|
|
|
|
@Log()
|
|
def getByUser(self,user):
|
|
"""Get ids corresponding to category
|
|
:Returns: `[uid]`|None matchIds
|
|
"""
|
|
l = None
|
|
r = [ k for i,k in enumerate(self.dic) if not k.startswith(self.SEP_KEY_INTERN) and regsearch(user,self.getUser(self.dic[k][self.USER])) is not None ]
|
|
l = [self.dic[k][self.UID] for k in r]
|
|
return l
|
|
|
|
|
|
@Log()
|
|
def getIntersection(self,list1, list2):
|
|
"""Get ids intercept list1 and list2
|
|
:Returns: `[uid]`|None matchIds
|
|
"""
|
|
l = [ i for i in set(list1).intersection(set(list2))]
|
|
return l
|
|
|
|
|
|
@Log()
|
|
def encrypt(self, fromPath=None):
|
|
""""""
|
|
if fromPath is None :
|
|
fromPath = self.pathPlain
|
|
Sys.pwlog([(' Encrypt Index... ' , Const.CLZ_0, True)])
|
|
Io.set_data(fromPath, jdumps(self.dic))
|
|
call = ' '.join([Sys.executable, 'kirmah-cli.py', 'enc', '-qfj2' if Sys.isUnix() else '-qf', fromPath, '-z', '-r', '-m', '-o', fromPath+Kirmah.EXT, '-k', self.keyPath ])
|
|
#~ print(call)
|
|
Sys.sysCall(call)
|
|
Io.removeFile(fromPath)
|
|
Sys.pwlog([(' done', Const.CLZ_2, True)])
|
|
return Io.get_data(fromPath+Kirmah.EXT, True)
|
|
|
|
|
|
@Log(Const.LOG_APP)
|
|
def decrypt(self, fromPath=None):
|
|
""""""
|
|
done = False
|
|
try :
|
|
if fromPath is None :
|
|
fromPath = self.path
|
|
toPath = fromPath[:-len(Kirmah.EXT)] if fromPath.endswith(Kirmah.EXT) else fromPath+'.dump'
|
|
if Io.file_exists(fromPath) :
|
|
Sys.pwlog([(' Decrypt Index... ' , Const.CLZ_0, True)])
|
|
call = ' '.join([Sys.executable, 'kirmah-cli.py', 'dec', '-qfj2' if Sys.isUnix() else '-qf', fromPath, '-z', '-r', '-m', '-o', toPath, '-k', self.keyPath ])
|
|
print(call)
|
|
Sys.sysCall(call)
|
|
data = jloads(Io.get_data(toPath))
|
|
Io.removeFile(toPath)
|
|
else :
|
|
data = {}
|
|
done = True
|
|
except ValueError as e:
|
|
raise BadKeyException(e)
|
|
Sys.pwlog([(' done'if done else ' ko' , Const.CLZ_2 if done else Const.CLZ_1, True)])
|
|
return data
|
|
|
|
|
|
@Log(Const.LOG_ALL)
|
|
def print(self,order='ID', matchIds=None):
|
|
"""Print index content as formated bloc"""
|
|
#~ Sys.clear()
|
|
#~ Cli.print_header()
|
|
#~ AbstractCli.printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
|
|
|
|
inv = order.startswith('-')
|
|
if inv : order = order[1:]
|
|
orderIndex = self.COLS.index(order)
|
|
if orderIndex is None : orderIndex = self.COLS.index('ID')
|
|
d = sorted([(self.dic.get(k),k) for i, k in enumerate(self.dic) if not k.startswith(self.SEP_KEY_INTERN)], reverse=inv, key=lambda lst:lst[0][orderIndex])
|
|
|
|
sizeid = 1+Sys.ceil(len(str(len(d))))
|
|
if sizeid < 3 : sizeid = 3
|
|
addsize = abs(3 - sizeid);
|
|
|
|
sort = '^' if inv else '_' #'ↆ'
|
|
|
|
space = (4+addsize, 8, 38, 10, 3, 5, 11, 24-addsize, 13)
|
|
for i, s in enumerate(self.COLS[:-1]):
|
|
symb, c = sort if order == s else ' ', Sys.Clz.BG4+Sys.Clz.fgB7 if order != s else Sys.Clz.BG7+Sys.Clz.fgB4
|
|
Sys.echo ((' '+s+symb).ljust(space[i],' ') , c, False, False)
|
|
Sys.echo('', c)
|
|
Sys.echo(Const.LINE_SEP_CHAR*Const.LINE_SEP_LEN, Sys.CLZ_HEAD_LINE)
|
|
|
|
a = ''
|
|
tsize = 0
|
|
psize = 0
|
|
acc = {}
|
|
wrap = '… ' if Sys.isUnix() else '/ '
|
|
for v,k in d :
|
|
if matchIds==None or v[self.UID] in matchIds:
|
|
if v[self.SIZE] == '' : v[self.SIZE] = 0
|
|
a = ''
|
|
Sys.echo(str(v[self.UID]).rjust(sizeid+1,' ') , Sys.Clz.bg1+Sys.Clz.fgB7, False)
|
|
Sys.echo(' '+str(k).ljust(9,' ')[0:6]+wrap , Sys.Clz.fgN2, False)
|
|
if len(v[self.LABEL])>36 : a = wrap
|
|
try:
|
|
Sys.echo(str(v[self.LABEL][:36]+a).ljust(38,' ') , Sys.Clz.fgN7, False)
|
|
except:
|
|
pass
|
|
j = 0
|
|
for c in v[self.LABEL][:36] :
|
|
try:
|
|
Sys.echo(str(c) , Sys.Clz.fgN7, False, False)
|
|
except:
|
|
Sys.echo('?' , Sys.Clz.fgN7, False, False)
|
|
j += 1
|
|
Sys.echo(''.ljust(38-j,' ') , Sys.Clz.fgN7, False, False)
|
|
|
|
a = ''
|
|
Sys.echo(Sys.readableBytes(v[self.SIZE])[:9].rjust(9,' ')+' '*2 , Sys.Clz.fgN5, False)
|
|
Sys.echo(str(v[self.PARTS]).rjust(2 ,'0') +' '*2 , Sys.Clz.fgN1, False)
|
|
Sys.echo(str(v[self.EXT][:6]).ljust(7,' ') , Sys.Clz.fgn3, False)
|
|
Sys.echo(self.getUser(str(v[self.USER])).ljust(11 ,' ') , Sys.Clz.fgn7, False)
|
|
#~ Sys.echo(str(v[self.CATG]).ljust(30 ,' ') , Clz.fgN3)
|
|
if len(v[self.CATG])>22 : a = wrap
|
|
Sys.echo(str(v[self.CATG][:22]+a).ljust(24 ,' ') , Sys.Clz.fgN3, False)
|
|
a = ''
|
|
if len(v)-2==self.ACCOUNT:
|
|
if v[self.ACCOUNT] in self.acclist :
|
|
if len(self.acclist[v[self.ACCOUNT]])>11 : a = '…'
|
|
Sys.echo(str(self.acclist[v[self.ACCOUNT]][:11]+a).ljust(12 ,' ') , Sys.Clz.fgN4)
|
|
else :
|
|
Sys.echo(str(v[self.ACCOUNT][:11]+'!').ljust(12 ,' ') , Sys.Clz.fgN4)
|
|
if v[self.ACCOUNT] in acc :
|
|
acc[v[self.ACCOUNT]] += int(v[self.SIZE])
|
|
else : acc[v[self.ACCOUNT]] = int(v[self.SIZE])
|
|
else: Sys.dprint()
|
|
|
|
psize += int(v[self.SIZE])
|
|
tsize += int(v[self.SIZE])
|
|
if len(d)==0:
|
|
Sys.echo(' empty', Sys.Clz.fgB1)
|
|
|
|
Sys.echo(Const.LINE_SEP_CHAR*Const.LINE_SEP_LEN, Sys.CLZ_HEAD_LINE)
|
|
c = Sys.Clz.fgB2
|
|
if psize != tsize : c = Sys.Clz.fgB7
|
|
Sys.echo(' size : ', Sys.Clz.fgB3, False)
|
|
Sys.echo(Sys.readableBytes(psize)[:9].rjust(9,' '), c, False)
|
|
if psize != tsize :
|
|
Sys.echo(' / ', Sys.Clz.fgB3, False)
|
|
Sys.echo(Sys.readableBytes(tsize), Sys.Clz.fgB2, False)
|
|
Sys.dprint()
|
|
Sys.echo(Const.LINE_SEP_CHAR*Const.LINE_SEP_LEN, Sys.CLZ_HEAD_LINE)
|
|
|
|
#~ Sys.echo(' '*4+'[', Sys.Clz.fgB7, False)
|
|
#~ sep = ''
|
|
#~ for k in acc:
|
|
#~ if k!= '':
|
|
#~ Sys.echo(sep+k,Sys.Clz.fgB3,False)
|
|
#~ Sys.echo(':',Sys.Clz.fgB7,False)
|
|
#~ Sys.echo(Sys.readableBytes(acc[k]),Sys.Clz.fgB2,False)
|
|
#~ if sep=='':sep = ','
|
|
#~ Sys.echo(']', Sys.Clz.fgB7, False)
|
|
#~ mprint()
|
|
|
|
|
|
|
|
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
# ~~ class IndexUpdater ~~
|
|
|
|
class IndexUpdater:
|
|
""""""
|
|
@Log(Const.LOG_BUILD)
|
|
def __init__(self, ih, conf, wkdir='./', emit=None):
|
|
""""""
|
|
self.idx = None
|
|
self.index = None
|
|
self.emit = emit
|
|
self.delids = []
|
|
self.ih = ih
|
|
self.conf = conf
|
|
self.pathIdx = wkdir+'.index.'+self.conf.profile+Kirmah.EXT
|
|
self.mb = MailBuilder(self.conf.get('salt','keys'))
|
|
self.rootBox = self.conf.get('box','imap')
|
|
self.get()
|
|
|
|
|
|
@Log(Const.LOG_DEBUG)
|
|
def _getId(self, notAssign=False):
|
|
""""""
|
|
idx = None
|
|
ids = self.ih.searchBySubject(self.mb.getHashName('index'),True)
|
|
if len(ids) > 0 and int(ids[0]) >= 0 :
|
|
idx = ids[-1]
|
|
if not notAssign: self.delids = ids[:-1]
|
|
if not notAssign:
|
|
self.idx = idx
|
|
return idx
|
|
|
|
|
|
@Log()
|
|
def get(self, forceRefresh=False):
|
|
""""""
|
|
self.switchFileAccount(self.conf.profile)
|
|
index = None
|
|
uid = self.conf.get('uid' ,'index')
|
|
date = self.conf.get('date' ,'index')
|
|
tstamp = self.conf.get('time' ,'index')
|
|
refresh = forceRefresh
|
|
delta = None if tstamp is None else Sys.datetime.now() - Sys.datetime.strptime(tstamp[:-7], '%Y-%m-%d %H:%M:%S')
|
|
if not refresh and tstamp is not None and delta < Sys.timedelta(minutes = 3) :
|
|
# getFromFile
|
|
if uid != None and Io.file_exists(self.pathIdx): # int(self.idx) == int(uid)
|
|
self.idx = uid
|
|
Sys.pwlog([(' Get index from cache ' , Const.CLZ_7),
|
|
('(' , Const.CLZ_0),
|
|
(str(int(self.idx)) , Const.CLZ_2),
|
|
(')' , Const.CLZ_0, True)])
|
|
else: refresh = True
|
|
else: refresh = True
|
|
self.irefresh = refresh
|
|
if refresh :
|
|
Sys.pwlog([(' Checking index...', Const.CLZ_0, True)])
|
|
self._getId()
|
|
if self.idx :
|
|
if int(self.idx) != int(uid) or not Io.file_exists(self.pathIdx):
|
|
Sys.pwlog([(' Refreshing index (local:', Const.CLZ_0),
|
|
(str(int(uid)) , Const.CLZ_2),
|
|
(' / remote:' , Const.CLZ_0),
|
|
(str(int(self.idx)) , Const.CLZ_1),
|
|
(')' , Const.CLZ_0, True)])
|
|
|
|
date = self.ih.headerField(self.idx, 'date', True)
|
|
self.conf.sets((['uid' , str(int(self.idx)) , 'index'],
|
|
['date' , date , 'index'],
|
|
['time' , str(Sys.datetime.now()), 'index']))
|
|
self._saveLocalIndex()
|
|
else :
|
|
Sys.pwlog([(' Get index from cache ' , Const.CLZ_7),
|
|
('(' , Const.CLZ_0),
|
|
(str(int(self.idx)) , Const.CLZ_2),
|
|
(')' , Const.CLZ_0, True)])
|
|
self.conf.set('time',str(Sys.datetime.now()),'index')
|
|
self.build()
|
|
|
|
|
|
@Log()
|
|
def build(self):
|
|
Sys.pwlog([(' Reading index, please wait...', Const.CLZ_7, True)])
|
|
self.index = ImpraIndex(self.conf.get('key','keys'), self.pathIdx, self.getIndexDefaultCatg(), self.getAccountList())
|
|
defUsers = self.conf.get('users','catg')
|
|
if not ImpraIndex.SEP_KEY_INTERN+'users' in self.index.dic:
|
|
self.index.dic[ImpraIndex.SEP_KEY_INTERN+'users'] = {}
|
|
for k in self.index.dic[ImpraIndex.SEP_KEY_INTERN+'users']:
|
|
if self.index.dic[ImpraIndex.SEP_KEY_INTERN+'users'][k] not in [ i.strip() for i in defUsers.split(',')]:
|
|
self.conf.set('users',defUsers+', '+self.index.dic[ImpraIndex.SEP_KEY_INTERN+'users'][k],'catg')
|
|
|
|
|
|
@Log(Const.LOG_DEBUG)
|
|
def getAccountList(self):
|
|
l = {}
|
|
pl = self.conf.get('multi','imap')
|
|
if pl is not None and len(pl)>0 :
|
|
pl = pl.split(',')
|
|
if len(pl) > 0:
|
|
if not self.conf.profile in pl:
|
|
pl.append(self.conf.profile)
|
|
else : pl = [self.conf.profile]
|
|
for p in pl : l[p] = self.conf.get('user','imap',p)
|
|
return l
|
|
|
|
|
|
@Log(Const.LOG_DEBUG)
|
|
def getIndexDefaultCatg(self):
|
|
""""""
|
|
usrName = self.conf.get('name','infos')
|
|
defUsers = self.conf.get('users','catg').split(',')
|
|
dic = {'catg':self.conf.get('types','catg'), 'users':{ ('%s' % self.mb.getHashName('all')) : 'all', ('%s' % self.mb.getHashName(usrName)) : usrName}}
|
|
for u in defUsers :
|
|
dic['users'][('%s' % self.mb.getHashName(u.strip()))] = u.strip()
|
|
return dic
|
|
|
|
|
|
@Log(Const.LOG_DEBUG)
|
|
def _saveLocalIndex(self):
|
|
""""""
|
|
if not self.idx : self._getId()
|
|
if self.idx :
|
|
msg = self.ih.getEmail(self.idx, True)
|
|
content = b''
|
|
for part in msg.walk():
|
|
content += part.get_payload(decode=True)
|
|
Io.set_data(self.pathIdx, a2b_base64(content), True)
|
|
|
|
|
|
@Log()
|
|
def removeLocal(self):
|
|
""""""
|
|
self.conf.rem('*','index')
|
|
self.conf.save()
|
|
self.idx = None
|
|
Io.removeFile(self.pathIdx)
|
|
|
|
|
|
@Log()
|
|
def remove(self):
|
|
""""""
|
|
self._getId()
|
|
try:
|
|
if self.idx!= None : self.delids.append(Io.bytes(self.idx))
|
|
self.ih.delete(self.delids, True)
|
|
self.idx = None
|
|
except Exception as e :
|
|
Sys.dprint('error : ')
|
|
Sys.dprint(e)
|
|
|
|
self.ih.clearTrash()
|
|
self.removeLocal()
|
|
|
|
|
|
@Log(Const.LOG_APP)
|
|
def update(self):
|
|
""""""
|
|
self.switchFileAccount(self.conf.profile)
|
|
try:
|
|
if self.idx != None :
|
|
if not isinstance(self.idx,bytes):
|
|
self.idx = Io.bytes(self.idx)
|
|
self.delids.append(self.idx)
|
|
except Exception as e :
|
|
Sys.dprint('error : ')
|
|
Sys.dprint(e)
|
|
|
|
self.index.fixDuplicateIds()
|
|
#~ self.index.fixAccount('gmail5')
|
|
self.index.encrypt()
|
|
msgIndex = self.mb.buildIndex(self.pathIdx)
|
|
_, self.idx = self.ih.send(msgIndex.as_string(), self.rootBox)
|
|
date = self.ih.headerField(self.idx, 'date', True)
|
|
self.conf.sets((['uid' , self.idx , 'index'],
|
|
['date' , date , 'index'],
|
|
['time' , str(Sys.datetime.now()), 'index']))
|
|
|
|
Sys.pwlog([(' Index updated (' , Const.CLZ_0),
|
|
(str(int(self.idx)) , Const.CLZ_2),
|
|
(') ' , Const.CLZ_0),
|
|
(str(date) , Const.CLZ_7, True)])
|
|
|
|
try :
|
|
self.ih.delete(self.delids, True)
|
|
except :
|
|
Sys.dprint('error : ')
|
|
Sys.dprint(e)
|
|
self.ih.clearTrash()
|
|
return True
|
|
|
|
@Log()
|
|
def switchFileAccount(self, profile=None, force=False):
|
|
""""""
|
|
pl = self.conf.get('multi','imap')
|
|
if pl is not None and len(pl)>0 :
|
|
pl = pl.split(',')
|
|
if len(pl) > 0:
|
|
if not self.conf.profile in pl:
|
|
pl.append(self.conf.profile)
|
|
iconf = self.ih.conf
|
|
account = self.conf.get('user','imap',profile)
|
|
if True or iconf.user != account :
|
|
# reinit
|
|
iconf.user = None
|
|
try :
|
|
if profile is None : profile = self.index.getLightestAccount(pl)
|
|
if profile in pl :
|
|
iconf.user = self.conf.get('user','imap',profile)
|
|
iconf.pwd = self.conf.get('pass','imap',profile)
|
|
iconf.host = self.conf.get('host','imap',profile)
|
|
iconf.port = self.conf.get('port','imap',profile)
|
|
self.ih.switchAccount(iconf, self.rootBox, force)
|
|
except BadLoginException as e:
|
|
Sys.dprint('Error : ')
|
|
Sys.dprint(e)
|
|
Sys.dprint('check your connection or your imap config for profile '+profile)
|
|
if profile is None: profile = self.conf.profile
|
|
return profile
|