Conjunto de mudanças 2591 no repositório publico


Ignorar:
Timestamp:
15/05/2006 12:01:59 (13 anos atrás)
Autor:
johnnysouza
Mensagem:

nada significativo

Localização:
PloneImapClient/trunk
Arquivos:
5 editados

Legenda:

Não Modificado
Adicionado
Removido
  • PloneImapClient/trunk/Cache.py

    r2582 r2591  
    5151        self._tool=None
    5252        self.user=None
    53         self._message = None
     53        self._message=None
    5454
    5555        # automatically set attributes where mutators exist
     
    6060            if mutator is not None and callable(mutator):
    6161                mutator(kwargs[key])
    62 
    63 
    64     def markAsRead(self,folder,UID):
    65         """
    66         Marca um e-mail como lido
    67         TODO implementar marcar como lida no servidor mas sem ler
    68         """
    69         for i in xrange(len(self._headers)):
    70             if self._headers[i].get_UID() == UID:
    71                 flags = self._headers[i].get_flags()
    72                 if not r'\Seen' in flags:
    73                     flags.append(r'\Seen')
    74                     self._headers[i].set_flags(flags)
    75                     return
    76         return
    77                    
    7862
    7963
     
    131115
    132116
    133 
    134 
    135     def set_headers(self,value):
    136         self._headers=value
    137 
    138 
    139     def set_folderAtual(self,value):
    140         self._folderAtual=value
    141 
    142 
    143117    def get_headers(self, folder):
    144118        if folder == self.get_folderAtual():
     
    149123
    150124
     125    def getMail(self,folder,UID):
     126        if self._message:
     127            if self._message[0] == UID:
     128                return self._message[1]
     129
     130        index = self._tool.getConecaoIndex()
     131        typ, data = self._tool.conecoes[index][1].select(folder)
     132        typ, data = self._tool.conecoes[index][1].UID('fetch',UID,'(RFC822)')
     133        msg = email.message_from_string(data[0][1])
     134        self.markAsRead(folder,UID)
     135        self._message = ( UID, msg )
     136        return self._message[1]
     137       
     138
     139    def set_message(self,value):
     140        self._message=value
     141
     142    def get_message(self):
     143        return self._message
     144
     145
     146    def set_folderAtual(self,value):
     147        self._folderAtual=value
     148
     149
    151150    def get_tool(self):
    152151        return self._tool
    153152
    154153
    155     def set_tool(self,value):
    156         self._tool=value
    157 
     154    def markAsRead(self,folder,UID):
     155        """
     156        Marca um e-mail como lido
     157        TODO implementar marcar como lida no servidor mas sem ler
     158        """
     159        for i in xrange(len(self._headers)):
     160            if self._headers[i].get_UID() == UID:
     161                flags = list(self._headers[i].get_flags())
     162                if not r'\Seen' in flags:
     163                    flags.append(r'\Seen')
     164                    self._headers[i].set_flags(tuple(flags))
     165                    return
     166        return
     167                   
    158168
    159169    def get_folders(self):
     
    176186        self._folders=value
    177187
    178     def getMail(self,folder,UID):
    179         if self._message:
    180             if self._message[0] == UID:
    181                 return self._message[1]
    182188
    183         index = self._tool.getConecaoIndex()
    184         typ, data = self._tool.conecoes[index][1].select(folder)
    185         typ, data = self._tool.conecoes[index][1].UID('fetch',UID,'(RFC822)')
    186         msg = email.message_from_string(data[0][1])
    187         self.markAsRead(folder,UID)
    188         self._message = ( UID, msg )
    189         return self._message[1]
    190        
     189    def set_tool(self,value):
     190        self._tool=value
    191191
    192192
  • PloneImapClient/trunk/Header.py

    r2582 r2591  
    4545        self._inicializar(info,header)
    4646
     47
    4748    def _init_attributes(self,*args,**kwargs):
    4849        #attributes
     
    5354        self._subject=None
    5455        self._UID=None
    55         self._falgs=None
     56        self._flags=None
    5657        self._date=None
    5758
     
    104105
    105106
    106 
    107107    def headerAsString(self,):
    108108        pass
     109
    109110
    110111    def extract(self,):
     
    120121        return d
    121122
    122     def set_to(self,value):
    123         self._to=value
     123
     124
     125
     126    def get_subject(self):
     127        return self._subject
     128
    124129
    125130    def get_to(self):
    126131        return self._to
    127132
    128     def set_cc(self,value):
    129         self._cc=value
     133
     134    def set_subject(self,value):
     135        self._subject=value
     136
     137
     138    def set_from(self,value):
     139        self._from=value
     140
     141
     142    def get_flags(self):
     143        return self._flags
     144
    130145
    131146    def get_cc(self):
    132147        return self._cc
    133148
    134     def set_from(self,value):
    135         self._from=value
     149
     150    def get_date(self):
     151        return self._date
     152
     153
     154    def get_replyTo(self):
     155        return self._replyTo
     156
     157
     158    def set_flags(self,value):
     159        self._flags=value
     160
    136161
    137162    def get_from(self):
    138163        return self._from
    139164
     165
     166    def set_to(self,value):
     167        self._to=value
     168
     169
     170    def set_date(self,value):
     171        self._date=value
     172
     173
    140174    def set_replyTo(self,value):
    141175        self._replyTo=value
    142176
    143     def get_replyTo(self):
    144         return self._replyTo
    145 
    146     def set_subject(self,value):
    147         self._subject=value
    148 
    149     def get_subject(self):
    150         return self._subject
    151 
    152     def set_UID(self,value):
    153         self._UID=value
    154177
    155178    def get_UID(self):
    156179        return self._UID
    157180
    158     def set_flags(self,value):
    159         self._flags=value
    160181
    161     def get_flags(self):
    162         return self._flags
     182    def set_cc(self,value):
     183        self._cc=value
    163184
    164     def set_date(self,value):
    165         self._date=value
    166185
    167     def get_date(self):
    168         return self._date
    169 
     186    def set_UID(self,value):
     187        self._UID=value
    170188
    171189
  • PloneImapClient/trunk/ImapClient.py

    r2582 r2591  
    3131# additional imports from tagged value 'import'
    3232import imaplib
     33from Products.PloneImapClient.Cache import Cache
    3334import email
    34 from Products.PloneImapClient.Cache import Cache
    3535
    3636from Products.PloneImapClient.config import *
     
    233233
    234234
    235     def maskAsRead(self,folder,UID):
    236         """
    237         Marca um e-mail como lido
    238         TODO implementar marcar como lida no servidor mas sem ler
    239         """
    240         index = self.getCacheIndex()
    241         return self._caches[index].markAsRead(folder,UID)
     235
     236    security.declarePublic('markAsREad')
     237    def markAsREad(self,folder,UID):
     238        """
     239       
     240        """
     241       
     242        pass
    242243
    243244
     
    268269
    269270
     271
     272    security.declarePublic('getHeaders')
     273    def getHeaders(self,folder):
     274        """
     275            Pega os Headers da Cache e trata-os, possibilitando uso na ZMI       
     276        """
     277        i = self.getCacheIndex()
     278        h= self.caches[i].get_headers(folder)
     279        h2 = []
     280        for j in h:
     281            h2.append(j.extract())
     282        return h2
     283
     284
     285
     286    security.declarePublic('getFolders')
     287    def getFolders(self,):
     288        """
     289       
     290        """
     291        i = self.getCacheIndex()
     292        return self.caches[i].get_folders()
     293
     294
     295
     296    security.declarePublic('sentMail')
     297    def sentMail(self,mail):
     298        """
     299       
     300        """
     301       
     302        pass
     303
     304
     305
     306    security.declarePublic('delMail')
     307    def delMail(self,folder,index):
     308        """
     309       
     310        """
     311       
     312        pass
     313
     314
     315
     316    security.declarePublic('moveMail')
     317    def moveMail(self,folder,index,destino):
     318        """
     319       
     320        """
     321       
     322        pass
     323
     324
     325
     326    security.declarePublic('copyMail')
     327    def copyMail(self,folder):
     328        """
     329       
     330        """
     331       
     332        pass
     333
     334
     335
     336    security.declarePublic('newFolder')
     337    def newFolder(self,pai,nome):
     338        """
     339       
     340        """
     341       
     342        pass
     343
     344
     345
     346    security.declarePublic('delFolder')
     347    def delFolder(self,nome):
     348        """
     349       
     350        """
     351       
     352        pass
     353
     354
     355
    270356    security.declarePublic('getListaAnexos')
    271357    def getListaAnexos(self,folder='INBOX',UID=0):
     
    307393
    308394
    309 
    310     security.declarePublic('getHeaders')
    311     def getHeaders(self,folder):
    312         """
    313             Pega os Headers da Cache e trata-os, possibilitando uso na ZMI       
    314         """
    315         i = self.getCacheIndex()
    316         h= self.caches[i].get_headers(folder)
    317         h2 = []
    318         for j in h:
    319             h2.append(j.extract())
    320         return h2
    321 
    322 
    323     security.declarePublic('getFolders')
    324     def getFolders(self,):
    325         """
    326        
    327         """
    328         i = self.getCacheIndex()
    329         return self.caches[i].get_folders()
    330 
    331 
    332 
    333     security.declarePublic('sentMail')
    334     def sentMail(self,mail):
    335         """
    336        
    337         """
    338        
    339         pass
    340 
    341 
    342 
    343     security.declarePublic('delMail')
    344     def delMail(self,folder,index):
    345         """
    346        
    347         """
    348        
    349         pass
    350 
    351 
    352 
    353     security.declarePublic('moveMail')
    354     def moveMail(self,folder,index,destino):
    355         """
    356        
    357         """
    358        
    359         pass
    360 
    361 
    362 
    363     security.declarePublic('copyMail')
    364     def copyMail(self,folder):
    365         """
    366        
    367         """
    368        
    369         pass
    370 
    371 
    372 
    373     security.declarePublic('newFolder')
    374     def newFolder(self,pai,nome):
    375         """
    376        
    377         """
    378        
    379         pass
    380 
    381 
    382 
    383     security.declarePublic('delFolder')
    384     def delFolder(self,nome):
    385         """
    386        
    387         """
    388        
    389         pass
     395    #manually created methods
     396
     397    def maskAsRead(self,folder,UID):
     398        """
     399        Marca um e-mail como lido
     400        TODO implementar marcar como lida no servidor mas sem ler
     401        """
     402        index = self.getCacheIndex()
     403        return self._caches[index].markAsRead(folder,UID)
    390404
    391405
  • PloneImapClient/trunk/version.txt

    r2533 r2591  
    1 0.1 build 76
     10.1 build 77
Note: Veja TracChangeset para ajuda no uso do visualizador de conjunto de mudanças.
 

The contents and data of this website are published under license:
Creative Commons 4.0 Brasil - Atribuir Fonte - Compartilhar Igual.