예제 #1
1
파일: yama.py 프로젝트: thomaswilley/yama
def sync(imap_endpoint, couchdb_endpoint, username, password, from_date, starttls=False):
    # https://pythonhosted.org/CouchDB/getting-started.html
    # assumes couchdb is running prior to running this...
    couch = couchdb.Server(couchdb_endpoint)
    dbname = 'messages_%s' % sha.sha(username).hexdigest()
    db = None
    try:
        db = couch[dbname]
    except:
        db = couch.create(dbname) # db didn't exist so create

    # https://github.com/martinrusev/imbox
    # note: using fresher fork: https://github.com/balsagoth/imbox
    imap_server = imap_endpoint
    imap_port = None
    imbox = None
    ssl = 'SSL'
    if starttls:
        ssl = 'STARTTLS'
    try:
        imap_server, imap_port = imap_endpoint.split(":")
        imbox = Imbox(imap_server, port=imap_port, username=username, password=password, ssl=ssl)
    except:
        imbox = Imbox(imap_server, username=username, password=password, ssl=ssl)

    # todo: sync point (set from_date to) day prior to most recent day stored in db
    all_messages = imbox.messages(date__gt=from_date)

    print "syncing messages to couch db [%s]" % db

    for uid, message in all_messages:
        print uid, message.subject, sync_message_with_couchdb(uid, message, db)
예제 #2
1
def mail2pmid():
    imbox = Imbox(em_server, username=em_usr, password=em_pw)

    print '\n\nFetching emails ...',
    email_gen = (imbox.messages(sent_from=sender))
    while True:    
        try:
            msgs_l.append(email_gen.next())
        except StopIteration:
            break
        except Exception as e:
            print(e)
            sys.exit(1)

    print("Done.\nSuccessfully retrieved {} messages from NCBI.".format(len(msgs_l)))
    
    msgs_str = str(msgs_l)

    pat = re.compile(r'pubmed\/(?P<pmid>\d+)')

    pmids = re.findall(pat, msgs_str)

    pmids = list(set(pmids))

    print('Found {} unique PMIDs.\n'.format(len(pmids)))

    return pmids
예제 #3
0
 def mailsOfDay(self, day):
     imbox = Imbox(self.host, username=self.keys.username, password=self.keys.password, ssl=True)
     beforeDay = day - datetime.timedelta(days=1)
     afterDay = day + datetime.timedelta(days=1)
     rawMessages = imbox.messages(date__gt=beforeDay.strftime("%d-%b-%Y"), date__lt=afterDay.strftime("%d-%b-%Y"))
     data = []
     for uid, message in rawMessages:
         date = self.convertRfcDateIncTimezone_Easier(message.date)
         if date.date() == day:
             data.append((uid, date, message))
     return data
예제 #4
0
    def __init__(self):
        self.imbox = Imbox(settings.IMAP_HOST, username=settings.IMAP_USERNAME,
                password=settings.IMAP_PASSWORD)

        self.evernote = EvernoteClient(token=settings.EVERNOTE_TOKEN,
                sandbox=False)
        self.noteStore = self.evernote.get_note_store()
def get_unread_email(mailbox_credentials):
    all_unread_messages = []
    for mailbox in app_config.mailbox_credentials:
        imbox = Imbox(mailbox['imapserver'],
            username=mailbox['username'],
            password=mailbox['password'],
            ssl=True)

        try:
            this_mailbox_unread_messages = imbox.messages(unread=True)
        except:
            syslog.syslog(syslog.LOG_ERROR, "Error connecting to IMAP server "+mailbox['imapserver'])


        try:
            all_unread_messages.append(this_mailbox_unread_messages) #List exists, so postnum > 1
        except KeyError:
            all_unread_messages = [this_mailbox_unread_messages] #Must be a new list!
    return all_unread_messages
예제 #6
0
    def handle(self, *args, **options):
        logger.info("===== Started check_mail =====")
        imbox = Imbox(SETTINGS['imap_host'],
                      username=SETTINGS['username'],
                      password=SETTINGS['password'],
                      ssl=True)

        for project in Project.objects.all():
            logger.info("=== Processing project %s ===" % project.title)
            self.handle_messages(imbox, project)

        for alias in ProjectAlias.objects.all():
            logger.info("=== Processing alias '{alias}' for project '{project}' ===".format(
                    alias=alias.email,
                    project=alias.project.title)
            )
            self.handle_messages(imbox, alias.project, email=alias.email, assignee=alias.assignee)

        imbox.logout()
        logger.info("===== Finished check_mail =====")
예제 #7
0
def mail_loop(user):
    username = user.username
    password = user.mail_pass
    logging.debug("user is " + username + " password is " + password)
    if "gmail.com" in username:
        server = "imap.gmail.com"
    elif "yahoo.com" in username:
        server = "imap.mail.yahoo.com"
    else:
        raise NotImplementedError("only yahoo.com and gmail.com imaps supported")

    imb = Imbox(server, username, password, ssl=True)
    msgs = imb.messages(unread=True, sent_from="*****@*****.**")

    v = VPS.query.filter(VPS.idvpss == user.idvpss).first()
    http_proxy = "http://" + "@".join([":".join([str(v.login), str(v.password)]), ":".join([str(v.ip), str(v.port)])])

    my_env = os.environ.copy()
    my_env["http_proxy"] = http_proxy
    my_env["http_proxy"] = http_proxy

    for uid, msg in msgs:
        imb.mark_seen(uid)
        confirm_url = re.findall("https://post.craigslist.org/./.+/.+\r", msg.body["plain"][0])[0].replace("\r", "")
        logging.debug("confirm link is " + confirm_url)
        subprocess.call(
            [
                "python",
                "cragapp/admanager.py",
                "--action",
                "confirm",
                "--confirm_url",
                confirm_url,
                "--username",
                username,
            ],
            env=my_env,
        )
    # grab current ads state after confirmation
    subprocess.call(["python", "cragapp/syncronizer.py", "userscrap", "--iduser", str(user.idusers)], env=my_env)
예제 #8
0
class Reader(object):
    """ Reads the email and stuff. """

    def __init__(self):
        self.inbox = Imbox("imap.gmail.com", username=userName, password=userPassword, ssl=True)
        self.getMessages()

    def getMessages(self):
        self.messages = self.inbox.messages(unread=True)
        return self.messages

    def listMessageIds(self):
        """ More or less debug. """
        for message in self.messages:
            print(message[0])
예제 #9
0
class Everclip(object):

    def __init__(self):
        self.imbox = Imbox(settings.IMAP_HOST, username=settings.IMAP_USERNAME,
                password=settings.IMAP_PASSWORD)

        self.evernote = EvernoteClient(token=settings.EVERNOTE_TOKEN,
                sandbox=False)
        self.noteStore = self.evernote.get_note_store()

    def get_new_emails(self):
        emails = self.imbox.messages(sent_to=settings.TO_ADDRESS, unread=True)
        return list(emails)

    def process_email(self, email):
        # Plain is given as a list - in case of multipart perhaps?

        # 1. Identify URL's in email
        plain = ' '.join(email.body['plain'])
        urls = extract_urls_from_text(plain)
        # NOTE: what to do about multiple links? include all of them? For now,
        # just choose the first one.
        url = urls[0]

        # 2. Extract URL content
        title, text = extract_url_content(url)

        # 3. Add to EverNote
        note = Types.Note()
        note.title = title
        note.content = text_to_enml(text).encode('utf8')

        attributes = Types.NoteAttributes()
        attributes.sourceURL = url
        note.attributes = attributes

        note = self.noteStore.createNote(note)

    def run(self):
        # TODO: make this a self-running daemon that continously checks for new
        # emails at regular intervals.
        print "Checking for new emails..."
        emails = self.get_new_emails()
        print "No. of new emails: %d" % (len(emails),)
        for id, email in emails:
            self.process_email(email)
예제 #10
0
class GmailReader:
    def __init__(self):
        self.inbox = ''

    def create_and_login(self, username, password):
        self.inbox = Imbox('imap.gmail.com',
                           username=str(username),
                           password=str(password),
                           ssl=True,
                           ssl_context=None)

    def get_messages(self, folder):
        message_list = []

        folder = self.inbox.messages(folder=folder)
        for uid, email in folder:
            message_list.append(Message(raw_msg=str(email.body['plain'])))

        return message_list
예제 #11
0
    def pull(self, connection_info: JsonDict) -> Iterator[JsonDict]:
        """Pull emails from Gmail."""
        self.imbox = Imbox(
            connection_info["hostname"],
            port=connection_info.get("port", None),
            username=connection_info["user"],
            password=connection_info["password"],
            ssl=True,
            ssl_context=None,
            starttls=False,
        )
        self.search_url = connection_info["search_url"]
        self.search_date_format = connection_info["search_date_format"]
        self.mark_read = connection_info.get("mark_read", False)
        self.archive = connection_info.get("archive", False)
        self.archive_folder = connection_info["archive_folder"]

        kwargs = {}
        from_ = connection_info.get("from")
        if from_:
            kwargs["sent_from"] = from_
        label = connection_info.get("label")
        if label:
            kwargs.update(folder="all", label=label)
        folder = connection_info.get("folder")
        if folder:
            kwargs.update(folder=folder)
        messages = self.imbox.messages(**kwargs)
        if not messages:
            return []

        for uid, message in messages:
            self.current_uid = uid
            date = pendulum.instance(message.parsed_date).date()
            url = self.build_search_url(from_, date, date.add(days=1))
            subject: str = message.subject
            yield {
                "uid": uid.decode(),
                "url": url,
                "subject": " ".join(subject.splitlines()),
                "parsed_date": message.parsed_date.isoformat(),
            }
예제 #12
0
    def connect_to_imap(self):
        username = self.config.get('username', None)
        password = self.config_dir.children['password']._content
        host = self.config.get('host', None)
        ssl = self.config.get('ssl', '0')

        if not (username and password and host):
            self.set_status(
                'ERROR: you must set your username, password and host.\
({}, {}, {} ({}))'.format(username, '*' if password else 'None', host, ssl))
        else:
            self.set_status('Connecting to {}'.format(host))
            try:
                self.imbox = Imbox(host,
                                   username=username,
                                   password=password,
                                   ssl=(ssl != '0'))
            except Exception as ex:
                print(username, host, ssl)
                print(ex)
                self.set_status('Error: {}'.format(ex))
            else:
                self.connected = True
                self.load_folder('INBOX')
예제 #13
0
# Use https://github.com/martinrusev/imbox as IMAP Client
from imbox import Imbox
import json

# Load user credentials from JSON
with open('config.json', 'r') as configFile:
    config = json.loads(configFile.read())
    print(config['name'])

# Open inbox
imbox = Imbox('mail.sjtu.edu.cn',
              username=config['name'],
              password=config['password'],
              ssl=True,
              ssl_context=None)

# Gets all messages
all_messages = imbox.messages()

for uid, message in all_messages:
    # FIXME: UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc4 in position 1821: invalid continuation byte
    print(message)
예제 #14
0
# -*- coding: utf-8 -*-

#import yagmail
import keyring
from imbox import Imbox

#authcode = input("Authorization Code: ")
#yagmail.register('*****@*****.**',authcode)
mail_pass = keyring.get_password('yagmail','*****@*****.**')
with Imbox('imap.qq.com','*****@*****.**',mail_pass,ssl=True) as imbox:
    # imap服务器地址,邮箱,密码,是否支持ssl
    print('正在连接QQ邮箱...')
    unread_mails = imbox.messages(unread=True)
    # 读取收件箱所有信息
    for uid, messages in unread_mails:
        title = messages.subject
        sent_from = messages.sent_from
        print(f'收到来自{sent_from}的邮件\n邮件主题为:{title}\n')
        #imbox.mark_seen(uid)
        #print('已标记为已读')
예제 #15
0
def engine():
    # TODO: format time in report for normal template
    if request.method == 'POST':
        report = []
        time = datetime.now()
        print('START', (datetime.now() - time))
        report.append('START ' + str(datetime.now() - time))

        # Imbox - Python IMAP for Humans
        with Imbox('imap.yandex.com',
                   username='******',
                   password='******',
                   ssl=True,
                   ssl_context=None,
                   starttls=False) as imbox:
            inbox_messages = imbox.messages(date__on=date.today())
            print(inbox_messages)
            report.append(str(inbox_messages))

            for uid, message in inbox_messages[::-1]:
                r = message.attachments[0]['content']
                print(r)
                with open("new_price1.zip", "wb") as file:
                    file.write(r.read())
                    print('DONE')
                break

        print('Downloaded', (datetime.now() - time))
        report.append('Downloaded ' + str(datetime.now() - time))

        print('Start unzip', (datetime.now() - time))
        report.append('Start unzip ' + str(datetime.now() - time))
        with zipfile.ZipFile("new_price1.zip", "r") as zip_ref:
            zip_ref.extractall(".")

        print('Unzipped', (datetime.now() - time))
        report.append('Unzipped ' + str(datetime.now() - time))

        print('Init RAM and update Base', (datetime.now() - time))
        report.append('Init RAM and update Base ' + str(datetime.now() - time))

        # Объявляю переменные и загружаю ОЗУ
        old_base = Product.query.all()
        new_base = parse_db()
        old_art_list = []
        new_art_list = []
        upd_count = 0
        add_count = 0
        del_count = 0

        # Вывод количества элементов
        print(len(new_base), 'записей в прайсе')
        print(len(old_base), 'записей в БД')
        report.append(str(len(new_base)) + ' записей в прайсе')
        report.append(str(len(old_base)) + ' записей в БД')

        # Создание списков артикулов для ускорения индексации
        for el in old_base:
            old_art_list.append(el.article)

        for el in new_base:
            new_art_list.append(int(el[0]))

        print('Start update', (datetime.now() - time))
        report.append('Start update ' + str(datetime.now() - time))

        # Обновление БД (в ОЗУ) из прайса
        for prod in old_base:
            if prod.article in new_art_list:
                index = new_art_list.index(prod.article)
                prod.status = new_base[index][6]
                prod.price = new_base[index][7]
                prod.date_time = new_base[index][8]
                prod.delivery = new_base[index][9]
                db.session.add(prod)
                upd_count += 1

        print('UPD finished', upd_count, (datetime.now() - time))
        report.append('UPD finished ' + str(upd_count) + ' ' +
                      str(datetime.now() - time))

        # Если элемента в БД нет, создаю его
        for element in new_base:
            if int(element[0]) not in old_art_list:
                prod = Product(
                    article=element[0],
                    cat=element[1],
                    sub_cat=element[2],
                    sub_sub_cat=element[3],
                    title=element[4],
                    guarant=element[5],
                    status=element[6],
                    price=element[7],
                    date_time=element[8],
                    delivery=element[9],
                )
                db.session.add(prod)
                add_count += 1

        print('ADD finished', add_count, (datetime.now() - time))
        report.append('ADD finished ' + str(add_count) + ' ' +
                      str(datetime.now() - time))

        # Если элемента в ПРЙСЕ нет, удаляю его
        for element in old_art_list:
            if element not in new_art_list:
                prod = Product.query.filter_by(article=element).first()
                db.session.delete(prod)
                del_count += 1

        print('DEL finished', del_count, (datetime.now() - time))
        report.append('DEL finished ' + str(del_count) + ' ' +
                      str(datetime.now() - time))

        # Передаю изменения из ОЗУ в БД
        db.session.commit()

        print('Обновлено', upd_count, 'товаров')
        print('Добавлено', add_count, 'товаров')
        print(' Удалено ', del_count, 'товаров')
        report.append('Обновлено ' + str(upd_count) + ' товаров')
        report.append('Добавлено ' + str(add_count) + ' товаров')
        report.append(' Удалено  ' + str(del_count) + ' товаров')

        # Очистка памяти
        del new_base
        del old_base
        del new_art_list
        del old_art_list
        del upd_count
        del add_count
        del del_count
        del time

        report = '\n'.join(report)

        sendEMail(report)

        del report

        restart_server()

        return redirect('/'), PRODUCTS
    else:
        return render_template('engine.html')
예제 #16
0
def alta ( remitente ) :
    cursor, conn = fusuario(remitente)
    if cursor.fetchone() == None:
         add ( conn, cursor, ( remitente, 1, "diary", 7), "insert" )
    else:
         add ( conn, cursor, ( remitente, 1, "diary", 7), "update" )
    sendmail ("alta", remitente, 6)

def baja ( remitente ) :
    cursor, conn = fusuario(remitente)
    rem = cursor.fetchone()
    if rem != None:
        delete( conn, cursor, rem[2])
    sendmail ("baja", rem[2], 6)

imbox = Imbox( IMAPserver, mailUser, PASSWORD, True)
unread_messages = imbox.messages(unread=True)

for iud, message in unread_messages:
    sender = message.sent_from[0]['email']
    command = message.subject.lower()
    
    if sender == "*****@*****.**" or sender == "*****@*****.**":
        pass

    elif command.find('alta') > -1:
        alta( sender )
        imbox.delete( iud)
      
    elif command.find('baja') > -1:
        baja( sender )
예제 #17
0
    def iter_inbox(cls,
                   email=None,
                   password=None,
                   offset=0,
                   limit=0,
                   unread=False,
                   folder=None,
                   sent_from=None,
                   sent_to=None,
                   date=None,
                   date_from=None,
                   date_until=None,
                   mark_as_read=False,
                   move_to_folder=None,
                   **filters):
        def paginate(messages, offset, limit):
            paginate = None
            if offset and limit:
                paginate = (offset, offset + limit)
            elif offset:
                paginate = (offset, None)
            elif limit:
                paginate = [limit]
            if paginate:
                return islice(messages, *paginate)
            return messages

        email, password = cls.define_access_variables(email, password)
        # Prepare filters
        if unread:
            filters['unread'] = unread
        if folder:
            filters['folder'] = folder
        if sent_from:
            filters['sent_from'] = sent_from
        if sent_to:
            filters['sent_to'] = sent_to
        if date:
            filters['date__on'] = date
        if date_from:
            filters['date__gt'] = date_from
        if date_until:
            filters['date__lt'] = date_until

        with Imbox(cls.imap_server,
                   username=email,
                   password=password,
                   ssl=True,
                   ssl_context=None,
                   starttls=False) as imbox:
            # Filtering
            messages = imbox.messages(**filters)
            # Pagination
            messages = paginate(messages, offset, limit)
            # Iterate
            for uid, message in messages:
                if mark_as_read:
                    imbox.mark_seen(uid)
                if move_to_folder:
                    imbox.move(uid=uid, destination_folder=move_to_folder)
                yield DottedDict({
                    'id':
                    uid,
                    'from': [DottedDict(i) for i in message.sent_from],
                    'to': [DottedDict(i) for i in message.sent_to],
                    'date':
                    message.parsed_date,
                    'subject':
                    message.subject,
                    'body':
                    DottedDict(message.body),
                })
예제 #18
0
    ee = email.message_from_string(email_json["raw_email"])
    for i, j in ee.items():
        email_json["other"][i] = ee.get_all(i)

    return email_json


now = datetime.date.today()

while True:
    for key in r.scan_iter():
        login = json.loads(key)
        with Imbox(login["server"],
                   username=login["user"],
                   password=login["password"],
                   ssl=True,
                   ssl_context=None,
                   starttls=False) as imbox:
            inbox_messages_received_after = imbox.messages(date__gt=now)
            for uii, m in inbox_messages_received_after:
                if not r.get(key):
                    r.set(key, int(uii))
                elif int(uii) > int(r.get(key)):
                    r.set(key, int(uii))
                    producer.send("email", transform_email(m))
                    producer.flush()

    print("Checked")
    time.sleep(1)
예제 #19
0
class Module(BaseModule):
    def init(self):
        self.alive = True
        imap_thread = threading.Thread(target=self.imap_thread)
        imap_thread.start()
        self.imap_thread = imap_thread

        self.imap_folders = {}
        self.status_file = VirtualFile(self.status_dir, 'status')

        self.create_password_file()

        self.connected = False
        self.connect_to_imap()

        self.messages = {}

    def create_password_file(self):
        WriteOnlyfile(self.config_dir, 'password')

    def set_status(self, msg):
        self.status_file.content = msg

    def connect_to_imap(self):
        username = self.config.get('username', None)
        password = self.config_dir.children['password']._content
        host = self.config.get('host', None)
        ssl = self.config.get('ssl', '0')

        if not (username and password and host):
            self.set_status(
                'ERROR: you must set your username, password and host.\
({}, {}, {} ({}))'.format(username, '*' if password else 'None', host, ssl))
        else:
            self.set_status('Connecting to {}'.format(host))
            try:
                self.imbox = Imbox(host,
                                   username=username,
                                   password=password,
                                   ssl=(ssl != '0'))
            except Exception as ex:
                print(username, host, ssl)
                print(ex)
                self.set_status('Error: {}'.format(ex))
            else:
                self.connected = True
                self.load_folder('INBOX')

    def load_folder(self, name):
        self.set_status('Loading folder {}'.format(name))
        imap_folder_dir = ImapFolderDir(self.root, name, self)
        self.imap_folders[name] = imap_folder_dir

        by_date_dir = VirtualDir(imap_folder_dir, 'by-date')
        by_sender_dir = VirtualDir(imap_folder_dir, 'by-sender')

        for uid in self.imbox.messages(folder=name):
            try:
                msg = self.imbox.get_message(uid)
            except Exception as ex:
                print('Error fetching message: {!r}'.format(ex))
            else:
                self.messages[uid] = msg
                print(
                    msg.sent_from['email'],
                    msg.subject,
                    msg.date, msg.parsed_date,
                    msg.content_type
                )

    def destroy(self):
        self.alive = False

    def imap_thread(self):
        while self.alive:
            time.sleep(10)

    def update_config(self, new_config):
        super().update_config(new_config)
        if not self.connected:
            self.connect_to_imap()
예제 #20
0
with yagmail.SMTP(user='******',host='邮箱的 smtp 网址') as yag:
    body = '正文内容'
    img = '图片文件路径'
    yag.send(to=['收件人邮箱地址'],cc=['抄送人邮箱地址'],bcc=['密送人邮箱地址']subject='主题',contents=[body,img,yagmail.inline('邮件内容中内嵌图片文件路径')],attachments=['附件文件路径'])
    print('发送成功!!')


'''
接收邮箱所有附件
'''

from imbox import Imbox

pwd = keyring.get_password('yagmail','邮箱地址')
with Imbox('邮箱的 imap 网址','邮箱地址',pwd,ssl=True) as imbox:
    all_inbox_messages = imbox.messages()
    for uid, message in all_inbox_messages:
        print(message.subject)
        print(message.body['plain'])

'''
message.sent_from 发件人
message.sent_to 收件人
message.subject 主题
message.date 时间
message.body[‘plain’] 文本格式内容
message.body[‘html’] html格式内容
message.attchments 附件
'''
    mail_server = mail_config_select("Select your Mail: ")
    if mail_server:
        userName = input("Mail ID: ")
        passwd = getpass.getpass(prompt="Password: "******"선택값 오류 입니다")
        raise SystemExit

    detach_dir = '.'
    if mail_server[0] not in os.listdir(detach_dir):
        os.mkdir(mail_server[0])

    cal = dict((v, k) for k, v in enumerate(calendar.month_abbr))
    with Imbox(mail_server[0],
               username=userName,
               password=passwd,
               ssl=mail_server[2],
               ssl_context=None,
               starttls=False) as imbox:

        status, folder_list = imbox.folders()
        mail_box_dir = mail_dir_select(imbox, "select mail box: ")
        # if mail_box_dir:
        #     folder_messages = imbox.messages(folder=mail_box_dir)
        # else:
        #     folder_messages = imbox.messages()

        for message_box in mail_box_dir:
            print("메일박스: ", message_box)
            try:
                folder_messages = imbox.messages(
                    folder='"{}"'.format(message_box))
예제 #22
0
import keyring
from imbox import Imbox
import datetime

user_name = "*****@*****.**"

# keyring.set_keyring("<service>", "<user>", "<pwd>")
pwd = keyring.get_password("qq", user_name)

# imap服务器地址,邮箱,密码,是否支持ssl
with Imbox('imap.qq.com', user_name, pwd, ssl=True) as imbox:
    # 未读、日期在2021.7.1之后
    all_inbox_messages = imbox.messages(unread=True,
                                        date__gt=datetime.date(2021, 7, 1))
    for uid, message in all_inbox_messages:
        subject = message.subject
        if "email-delete-test" in subject:
            print(message.subject)
            print(message.body['plain'])
            imbox.delete(uid)
            print('delete [uid=%d,subject=%s]' % (int(uid), subject))
예제 #23
0
import csv, traceback, openpyxl,re, glob, datetime, calendar, os
from imbox import Imbox

# get unread email from gmail and download attachments
host = 'imap.gmail.com'
username = '******'
password = '******'
download_folder = 'C:\\Users\\sariz\\OneDrive\\Desktop\\myPythonScripts\\budgetCSV'

if not os.path.isdir('C:\\Users\\sariz\\OneDrive\\Desktop\\myPythonScripts\\budgetCSV'):
    os.makedirs('C:\\Users\\sariz\\OneDrive\\Desktop\\myPythonScripts\\budgetCSV', exist_ok= True)

mail = Imbox(host, username= username, password= password, ssl= True, ssl_context = None, starttls= False)
messages = mail.messages(subject = 'Transactions', unread = True)

for (uid,message) in messages:
    mail.mark_seen(uid)

    for idx, attachment in enumerate(message.attachments):
        try:
            att_fn = attachment.get('filename') 
            download_path = f"{download_folder}/{att_fn}"
            print(download_path)
            with open(download_path, "wb") as fp:
                fp.write(attachment.get('content').read())

        except:
            passprint(traceback.print_exc())

mail.logout
예제 #24
0
class EmailSource(BaseSource):
    """Email source."""

    imbox: Imbox
    current_uid: Optional[bytes] = None
    search_url: str
    search_date_format: str
    mark_read = False
    archive = False
    archive_folder: str

    def pull(self, connection_info: JsonDict) -> Iterator[JsonDict]:
        """Pull emails from Gmail."""
        self.imbox = Imbox(
            connection_info["hostname"],
            port=connection_info.get("port", None),
            username=connection_info["user"],
            password=connection_info["password"],
            ssl=True,
            ssl_context=None,
            starttls=False,
        )
        self.search_url = connection_info["search_url"]
        self.search_date_format = connection_info["search_date_format"]
        self.mark_read = connection_info.get("mark_read", False)
        self.archive = connection_info.get("archive", False)
        self.archive_folder = connection_info["archive_folder"]

        kwargs = {}
        from_ = connection_info.get("from")
        if from_:
            kwargs["sent_from"] = from_
        label = connection_info.get("label")
        if label:
            kwargs.update(folder="all", label=label)
        folder = connection_info.get("folder")
        if folder:
            kwargs.update(folder=folder)
        messages = self.imbox.messages(**kwargs)
        if not messages:
            return []

        for uid, message in messages:
            self.current_uid = uid
            date = pendulum.instance(message.parsed_date).date()
            url = self.build_search_url(from_, date, date.add(days=1))
            subject: str = message.subject
            yield {
                "uid": uid.decode(),
                "url": url,
                "subject": " ".join(subject.splitlines()),
                "parsed_date": message.parsed_date.isoformat(),
            }

    def build_search_url(self, from_: str = None, after: pendulum.Date = None, before: pendulum.Date = None) -> str:
        """Build the Gmail search URL."""
        search_terms = []
        if from_:
            search_terms.append(f"from:({from_})")
        if after:
            search_terms.append(f"after:{after.format(self.search_date_format)}")
        if before:
            search_terms.append(f"before:{before.format(self.search_date_format)}")

        quoted_terms = quote_plus(" ".join(search_terms))
        return f"{self.search_url}{quoted_terms}"

    def on_success(self):
        """Mark email as read and/or archive it, if requested."""
        if not self.current_uid:
            return
        if self.mark_read:
            self.imbox.mark_seen(self.current_uid)
        if self.archive:
            self.imbox.move(self.current_uid, self.archive_folder)
예제 #25
0
def make_imbox(account):
    imbox = Imbox('imap.gmail.com', account[acc_keys.username],
                  base64.b64decode(account[acc_keys.password]))
    return imbox
예제 #26
0
class MailReceiver:
    address: str
    server_address: str
    port: int

    context: SSLContext
    server: Imbox

    def __init__(self, *, address, password, server_address, ssl_context):
        self.address = address
        self.server_address = server_address
        # self.port = port
        self.server = Imbox(
            hostname=server_address,
            username=address,
            password=password,
            ssl=True,
            ssl_context=ssl_context,
        )

    def _add_label(self, flag: FLAGS):
        pass

    def _get_charset(self, message, default="utf-8"):
        # Taken from
        # http://ginstrom.com/scribbles/2007/11/19/parsing-multilingual-email-with-python/
        """Get the message charset"""

        if message.get_content_charset():
            return message.get_content_charset()

        if message.get_charset():
            return message.get_charset()

        return default

    def _get_header(header_text, default="utf-8"):
        # Taken from
        # http://ginstrom.com/scribbles/2007/11/19/parsing-multilingual-email-with-python/
        """Decode the specified header"""

        headers = decode_header(header_text)
        header_sections = [
            str(text, charset or default) for text, charset in headers
        ]
        return u"".join(header_sections)

    def _get_body(self, message):
        # Taken from
        # http://ginstrom.com/scribbles/2007/11/19/parsing-multilingual-email-with-python/
        """Get the body of the email message"""

        if message.is_multipart():
            # get the plain text version only
            text_parts = [
                part
                for part in typed_subpart_iterator(message, "text", "plain")
            ]
            body = []
            for part in text_parts:
                charset = self._get_charset(part, self._get_charset(message))
                body.append(
                    str(part.get_payload(decode=True), charset, "replace"))

            return u"\n".join(body).strip()

        else:
            # if it is not multipart, the payload will be a string
            # representing the message body
            body = str(message.get_payload(decode=True),
                       self._get_charset(message), "replace")
            return body.strip()

    def _move_message_to_folder(self, mail_id: int, folder_name: str):
        # if folder_name not in self.server.folders:
        #     self.server.create_folder(folder_name)
        self.server.move(mail_id, folder_name)

    def get_not_seen_messages(self,
                              mark_as_seen=False
                              ) -> typing.List[ProcessedMessage]:
        messages = self.server.messages()

        mails: typing.List[ProcessedMessage] = []

        for uid, message_data in messages:
            # email_message = email.message_from_bytes(message_data[b"RFC822"])
            body = message_data.body["plain"]
            date = message_data.parsed_date
            subject = message_data.subject
            mails.append(
                ProcessedMessage(uid=uid,
                                 body=body,
                                 subject=subject.replace("Re:", ""),
                                 date=date))

            self._move_message_to_folder(uid, Labels.SEEN_BY_DEV.value)

        return mails
예제 #27
0
    def verify_account_in_html_email(http_settings,
                                     imap_server,
                                     username,
                                     password,
                                     sender,
                                     clues,
                                     match_substring=False,
                                     ssl=True):

        from bringyourownproxies.errors import VerificationLinkNotFound, AccountProblem

        email_box = Imbox(imap_server, username, password, ssl)
        msgs = email_box.messages(sent_from=sender)
        verification_link = None

        if isinstance(clues, (list, tuple)):
            if not isinstance(clues[0], (list, tuple)):
                if len(clues) != 2:
                    raise AccountProblem(
                        'clues needs to be a list/tuple each containing 2 tuple/list items'
                    )
                else:
                    clues = [clues]
            else:
                for clue in clues:
                    if isinstance(clue, (list, tuple)):
                        if len(clue) != 2:
                            raise AccountProblem(
                                'clues needs to be a list/tuple each containing 2 tuple/list items'
                            )
                    else:
                        raise AccountProblem(
                            'clues needs to be a list/tuple each containing 2 tuple/list items'
                        )
        else:
            raise AccountProblem(
                'clues needs to be a list/tuple each containing 2 tuple/list items'
            )

        for msg in msgs:
            uid, email = msg
            doc = etree.fromstring(email.body['html'][0], HTMLParser())
            for a in doc.xpath('//a'):

                for clue in clues:
                    clue_attrib, clue_value = clue

                    if clue_attrib == 'text':
                        value_found = a.text
                    else:
                        value_found = a.attrib[clue_attrib]
                    if match_substring:
                        if value_found:
                            if clue_value in value_found:
                                verification_link = a.attrib['href']
                                break

                    if clue_value == value_found:
                        verification_link = a.attrib['href']
                        break

        if not verification_link:
            raise VerificationLinkNotFound(
                'Cannot find email verification link sent from:{sender}'.
                format(sender=sender))

        session = http_settings.session
        proxy = http_settings.proxy
        verify = session.get(verification_link, proxies=proxy)
        return verify.content
from imbox import Imbox

imbox = Imbox('imap.gmail.com',
              username='',# Gmail Username 
              password='',# Password
              ssl=True)

# Gets all messages 
all_messages = imbox.messages()

# Unread messages 
unread_messages = imbox.messages(unread=True)

for uid,message in unread_messages:
    print message.sent_from
    print message.body.plain
예제 #29
0

def send_to_trello(mail_content, subject):

    r = requests.post("https://api.trello.com/1/cards?key=" + \
                      API_KEY + "&token=" + OAUTH_TOKEN + \
                      "&name=" + subject + "&idList=" + \
                      trello_list_id + "&desc=" + \
                      mail_content)

    return r


with Imbox('imap.gmail.com',
           username=data['mail_username'],
           password=data['mail_password'],
           ssl=True,
           ssl_context=None,
           starttls=False) as imbox:

    fetch_mail_type = imbox.messages(sent_from=data['mail_from_username'])

    # Get all folders
    #status, folders_with_additional_info = imbox.folders()

    # Gets all messages from the inbox
    #all_inbox_messages = imbox.messages()

    for uid, message in fetch_mail_type:
        # Every message is an object with the following keys

        origin = message.sent_from
예제 #30
0
    def check_inbox(self, r=30):
        import keyring

        while True:
            with Imbox('imap.gmail.com',
                       username=EMAIL,
                       password=keyring.get_password('system', KEYRING_USER),
                       ssl=True,
                       ssl_context=None,
                       starttls=False) as imbox:

                unread_msgs = imbox.messages(unread=True)

                for uid, message in unread_msgs:
                    imbox.mark_seen(uid)

                    if '[CMD]' in message.subject:
                        self.cmd(message)

                    # make sure the sender is in the group
                    # make sure grp is in groups
                    # strip Re from subject field
                    try:
                        if 'Re' in message.subject.split(' ')[0]:
                            del message.subject.split(' ')[0]
                        grp = message.subject.split(' ')[0][1:-1]
                    except IndexError:
                        grp = ''

                    try:
                        msg_type = message.subject.split(' ')[1][1:-1]
                    except IndexError:
                        msg_type = ''

                    try:
                        option = message.subject.split(' ')[2][1:-1]
                    except IndexError:
                        option = ''

                    if msg_type == 'CRT' and option == self.passwd:
                        self.crt(message, grp)

                    ## All other cmds require valid grp
                    if not grp in self.groups: continue
                    if not message.sent_from[0]['email'] in self.groups[
                            grp].values():
                        continue

                    if 'BCAST' in message.subject:
                        self.bcst(message, grp)

                    if msg_type == 'WSPR' and option in '[From] Secret Santa]':
                        self.wspr_to(message, grp)

                    if msg_type == 'WSPR' and option in '[To] Secret Santa]':
                        self.wspr_from(message, grp)

                    if msg_type == 'ADD' and option == self.passwd:
                        self.add(message, grp)

                    if msg_type == 'RM':
                        self.rm(message, grp)

                    if msg_type == 'PWROLL' and option == 'Please_be_careful_1234567890' + self.passwd:
                        self.roll(grp)

                    if msg_type == 'ROLL':
                        self.reroll[grp].update(message.sent_from[0]['name'])
                        # 2/3 majority
                        if len(self.reroll[grp]) > 2 * len(
                                self.groups[grp]) / 3:
                            self.roll(grp)

            sleep(r)  # sleep for 30s to not spam email
예제 #31
0
import os
from imbox import Imbox
from sender import Mail, Message
import pendulum


imap = os.environ['GMAIL_IMAP']
user = os.environ['GMAIL_USER']
pwrd = os.environ['GMAIL_PASS']

if __name__ == "__main__":
    with Imbox(imap, username=user, password=pwrd,
               ssl=True, ssl_context=None,
               starttls=False) as imbox:
        drafts = imbox.messages(folder="[Gmail]/Drafts")
        todays_mail = []
        for uid, msg in drafts:
            if 'schedmail' in msg.subject.lower():
                date = msg.subject.lower().split(':')[1]
                today = pendulum.now().date().isoformat()
                subject_date = pendulum.parse(date).date().isoformat()
                if subject_date == today:
                    todays_mail.append(msg)

    mail = Mail('smtp.gmail.com', port=587, username=user,
                password=pwrd, use_tls=True)

    for i in todays_mail:
        msg = Message(i.subject.split(':')[-1])
        msg.fromaddr = (i.sent_from[0]['name'], i.sent_from[0]['email'])
        msg.to = [j['email'] for j in i.sent_to]
primary_working_directory = os.path.dirname(os.path.realpath(__file__))
download_folder = os.path.join(os.path.dirname(os.path.realpath(__file__)),
                               'retrieved_downloads', 'vinsolutions')
print('Download forlder is: ', download_folder)

if not os.path.isdir(download_folder):
    os.makedirs(download_folder, exist_ok=True)
#Builds list of day params as integers to match imbox's weird snytax
today = date.today().strftime('%Y,%m,%d').split(',')
today = [int(x) for x in today]
print(today)

mail = Imbox(host,
             username=username,
             password=password,
             ssl=True,
             ssl_context=None,
             starttls=False)

#This is Part 1 of 2 that downloads the BDC Data from emails in today's inbox
messages = mail.messages(subject='VSLeadPull',
                         date__on=date(today[0], today[1],
                                       today[2]))  # Subject Contains String

for (uid, message) in messages:
    mail.mark_seen(uid)  # optional, mark message as read
    for idx, attachment in enumerate(message.attachments):
        try:
            att_fn = attachment.get('filename')
            download_path = f"{download_folder}/BDC_{att_fn}"
            print("Download: ", download_path)
예제 #33
0
def new_message(request):
    imbox = Imbox('imap.gmail.com',
                  username='******',
                  password='******',
                  ssl=True,
                  ssl_context=None,
                  starttls=False)

    last_message = IncomingEmail.objects.first()
    ll = LastMessage.objects.all()[0]

    if last_message != None:
        ll.date = last_message.date
        ll.save()
    last_message_date = ll.date
    print(last_message_date)
    all_inbox_messages = imbox.messages()

    for uid, message in all_inbox_messages:
        d = message.date.replace('(GMT)', '').strip()
        date = datetime.strptime(d, '%a, %d %b %Y %H:%M:%S %z')

        if date > last_message_date:
            #uid = message.message_id.replace('<','').replace('@mail.gmail.com>','')
            subject = message.subject
            from_name = message.sent_from[0]['name']
            from_email = message.sent_from[0]['email']
            to_name = message.sent_to[0]['name']
            to_email = message.sent_to[0]['email']
            body_plain = message.body['plain'][0]
            body_html = message.body['html'][0]
            date = date
            incoming = IncomingEmail(
                uid=uid,
                subject=subject,
                from_name=from_name,
                from_email=from_email,
                to_name=to_name,
                to_email=to_email,
                body_plain=body_plain,
                body_html=body_html,
                date=date,
            )
            incoming.save()
            print('yenimail eklendi')
    new_coming_message = IncomingEmail.objects.filter(
        date__gt=last_message_date)
    reply_array = []
    #my_incoming = []
    #all_incoming = []
    for mail in new_coming_message:
        reply_persons = mail.reply_persons.all()
        reply_p = serializers.serialize('json', reply_persons)
        reply_array.append(reply_p)
        #if person in reply_persons:
        #    my_incoming.append([mail,reply_persons])
        #all_incoming.append([mail,reply_persons])

    new_msg = serializers.serialize('json', new_coming_message)
    reply_json = json.dumps(reply_array)
    data = {'reply': reply_json, 'new_msg': new_msg}
    return JsonResponse(data)
예제 #34
0
        async def call():
            print("websocet contect kurdu ve 100 sn bir new message istiyor!!!")
            imbox = Imbox('imap.gmail.com',
                          username='******',
                          password='******',
                          ssl=True,
                          ssl_context=None,
                          starttls=False)
            last_message = MessageBlock.objects.last()
            ll = LastMessage.objects.all()[0]

            if last_message != None:
                ll.date = last_message.date
                ll.save()
            last_message_date = ll.date
            print(last_message_date, "consemer içinden son mesaj zamanı")
            all_inbox_messages = imbox.messages(date__gt=last_message_date)
            new_messages = []
            instance_new_messages = []
            for uid, message in all_inbox_messages:
                d = message.date.replace('(GMT)', '').strip()
                date = datetime.strptime(d, '%a, %d %b %Y %H:%M:%S %z')
                if date > last_message_date:
                    # uid = message.message_id.replace('<','').replace('@mail.gmail.com>','')
                    subject = message.subject
                    my_attachments = message.attachments
                    print('*****************Sadece gelen mesaj öncekileri istemiyoruz************************')
                    cc = message.body['html'][0]
                    print(cc.partition("<br>"))
                    print('*****************************************')
                    instance = cc.partition('<br>')
                    only_coming_message = instance[0]
                    from_name = message.sent_from[0]['name']
                    from_email = message.sent_from[0]['email']
                    to_name = message.sent_to[0]['name']
                    to_email = message.sent_to[0]['email']
                    body_plain = message.body['plain'][0]
                    body_html = only_coming_message
                    date = date
                    incoming = Message(
                        message_type='incoming',
                        uid=uid,
                        subject=subject,
                        name=from_name,
                        email=from_email,
                        body_plain=body_plain,
                        body_html=body_html,
                        date=date,
                    )
                    # incoming.mail_attachments.add()
                    incoming.save()
                    new_messages.append(incoming)
                    instance_new_messages.append(incoming)
                    print('yenimail eklendi db-ye ve new_mails array ine eklendi eklendi')

            all_message_blocks = MessageBlock.objects.all()
            message_blocks = [[e.email, e.subject] for e in  all_message_blocks]
            print(message_blocks, "Query deneme")
            for message in new_messages:
                for message_block in all_message_blocks:
                    if message_block.messages.filter(subject='Re:{}'.format(message.subject),email=message.email).exists():
                        print('cevap message ı geldi')
                        instance_new_messages = [x for x in instance_new_messages if x != message]

            print(instance_new_messages,'Buda hiç bir messaga bloğunda olmayan mesagges')
            new_blocks = [
                MessageBlock(
                    subject=nw_blk.subject,
                    name=nw_blk.name,
                    email=nw_blk.email,
                    date=nw_blk.date
                )
                for nw_blk in instance_new_messages
            ]
            print(new_blocks,"news blocks listesi")
            for i in range(len(new_blocks)):
                new_blocks[i].save()
                new_blocks[i].messages.add(instance_new_messages[i])
            await self.send(text_data=json.dumps({
                'message': 'message'
            }))
예제 #35
0
    if cursor.fetchone() == None:
        add(conn, cursor, (remitente, 1, "diary", 7), "insert")
    else:
        add(conn, cursor, (remitente, 1, "diary", 7), "update")
    sendmail("alta", remitente, 6)


def baja(remitente):
    cursor, conn = fusuario(remitente)
    rem = cursor.fetchone()
    if rem != None:
        delete(conn, cursor, rem[2])
    sendmail("baja", rem[2], 6)


imbox = Imbox(IMAPserver, mailUser, PASSWORD, True)
unread_messages = imbox.messages(unread=True)

for iud, message in unread_messages:
    sender = message.sent_from[0]['email']
    command = message.subject.lower()

    if sender == "*****@*****.**" or sender == "*****@*****.**":
        pass

    elif command.find('alta') > -1:
        alta(sender)
        imbox.delete(iud)

    elif command.find('baja') > -1:
        baja(sender)
예제 #36
0
    def verify_account_in_plain_email(http_settings,
                                      imap_server,
                                      username,
                                      password,
                                      sender,
                                      regexes,
                                      ssl=True):

        import re
        from imbox import Imbox

        from bringyourownproxies.errors import VerificationLinkNotFound, AccountProblem

        email_box = Imbox(imap_server, username, password, ssl)
        msgs = email_box.messages(sent_from=sender)
        verification_link = None
        if isinstance(regexes, (list, tuple)):
            if not isinstance(regexes[0], (list, tuple)):
                if len(regexes) != 2:
                    raise AccountProblem(
                        'regexes needs to be a list/tuple each containing 2 tuple/list items' \
                        ' one item is the regex the other is the group num when found')
                else:
                    regexes = [regexes]
            else:
                for regex in regexes:
                    if isinstance(regex, (list, tuple)):
                        if len(regex) != 2:
                            raise AccountProblem(
                                    'regexes needs to be a list/tuple each containing 2 tuple/list items' \
                                        ' one item is the regex the other is the group num when found')
                    else:
                        raise AccountProblem(
                                    'regexes needs to be a list/tuple each containing 2 tuple/list items' \
                                    ' one item is the regex the other is the group num when found')
        else:
            raise AccountProblem(
                        'regexes needs to be a list/tuple each containing 2 tuple/list items' \
                        ' one item is the regex the other is the group num when found')

        for msg in msgs:
            uid, email = msg
            content = email.body['plain'][0]
            for regex_config in regexes:
                regex, group_num = regex_config

                found = re.search(regex, content)
                if found:
                    verification_link = found.group(group_num)
                    break
            if verification_link:
                break

        if not verification_link:
            raise VerificationLinkNotFound('Could not find verification' \
                                           'link from sender:{sender}'.format(sender=sender))

        session = http_settings.session
        proxy = http_settings.proxy
        verify = session.get(verification_link, proxies=proxy)
        return verify.content
예제 #37
0
class EmailSource(BaseSource):
    """Email source."""

    imbox: Imbox
    current_uid: Optional[bytes] = None
    search_url: str
    search_date_format: str
    mark_read = False
    archive = False
    archive_folder: str

    def pull(self, connection_info: JsonDict) -> Iterator[JsonDict]:
        """Pull emails from GMail."""
        self.imbox = Imbox(
            connection_info["hostname"],
            port=connection_info.get("port", None),
            username=connection_info["user"],
            password=connection_info["password"],
            ssl=True,
            ssl_context=None,
            starttls=False,
        )
        self.search_url = connection_info["search_url"]
        self.search_date_format = connection_info["search_date_format"]
        self.mark_read = connection_info.get("mark_read", False)
        self.archive = connection_info.get("archive", False)
        self.archive_folder = connection_info["archive_folder"]

        kwargs = {}
        search_from = connection_info.get("from")
        if search_from:
            kwargs["sent_from"] = search_from
        label = connection_info.get("label")
        if label:
            kwargs.update(folder="all", label=label)
        folder = connection_info.get("folder")
        if folder:
            kwargs.update(folder=folder)
        messages = self.imbox.messages(**kwargs)
        if not messages:
            return []

        for uid, message in messages:
            self.current_uid = uid
            date = pendulum.instance(message.parsed_date).date()
            subject: str = " ".join(message.subject.splitlines())

            # First sender of the email
            message_from = message.sent_from[0].get(
                "email") if message.sent_from else None
            url = self.build_search_url(search_from or message_from, date,
                                        date.add(days=1), subject)

            yield {
                "from_": search_from or message_from,
                "uid": uid.decode(),
                "url": url,
                "subject": subject,
                "parsed_date": message.parsed_date.isoformat(),
            }

    def build_search_url(self,
                         from_: str = None,
                         after: pendulum.Date = None,
                         before: pendulum.Date = None,
                         subject=None) -> str:
        """Build the email search URL."""
        search_terms = []
        if from_:
            search_terms.append(f"from:({from_})")
        if after:
            search_terms.append(
                f"after:{after.format(self.search_date_format)}")
        if before:
            search_terms.append(
                f"before:{before.format(self.search_date_format)}")
        if subject:
            search_terms.append(f'subject:"{subject}"')

        quoted_terms = quote_plus(" ".join(search_terms))
        return f"{self.search_url}{quoted_terms}"

    def on_success(self):
        """Mark email as read and/or archive it, if requested."""
        if not self.current_uid:
            return
        if self.mark_read:
            self.imbox.mark_seen(self.current_uid)
        if self.archive:
            self.imbox.move(self.current_uid, self.archive_folder)
예제 #38
0
def test_user_connection_data(imap, username, password):
    try:
        Imbox(imap, username, password, True, None, False)
        return True
    except Exception as e:
        return False
예제 #39
0
 def create_and_login(self, username, password):
     self.inbox = Imbox('imap.gmail.com',
                        username=str(username),
                        password=str(password),
                        ssl=True,
                        ssl_context=None)
# -*- coding:utf-8 -*-
"""
作者:snackdeng
日期:2020/07/08
"""
import keyring
from imbox import Imbox

password = keyring.get_password('yagmail', '*****@*****.**')
print(password)
with Imbox('imap.163.com', '*****@*****.**', 'DINODMVPZVSBPYKA',
           ssl=True) as imbox:
    all_index_messages = imbox.messages()
    # imbox.messages(unread=True)  未读邮件
    # imbox.messages(flagged=True)  红旗邮件
    # imbox.messages(send_to='*****@*****.**')  某收件人邮件
    for uid, message in all_index_messages:
        # imbox.mark_seen(uid)  标记已读
        # imbox.delete(uid)  删除邮件
        print(message.subject)
        print(message.body['plain'])

        # message.sent_from 收件人
        # message.sent_to   发件人
        # message.subject   主题
        # message.date      时间
        # message.body['plain'] 文本格式内容
        # message.body['html'] HTML格式内容
        # message.attachments 附件
예제 #41
0
import traceback
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--folder", help="Show download_folder", type=str)
args = parser.parse_args()

host = "imap.gmail.com"
username = "******"
password = '******'
download_folder = args.folder
if not os.path.isdir(download_folder):
    os.makedirs(download_folder, exist_ok=True)

mail = Imbox(host,
             username=username,
             password=password,
             ssl=True,
             ssl_context=None,
             starttls=False)
messages = mail.messages()

for (uid, message) in messages:
    mail.mark_seen(uid)

    for idx, attachment in enumerate(message.attachments):
        try:
            att_fn = attachment.get('filename')
            download_path = f"{download_folder}\{att_fn}"
            print(download_path)
            if ((att_fn.find('CV') != -1) or (att_fn.find('cv') != -1)) and (
                (os.path.splitext(att_fn)[1] == '.pdf') or
                (os.path.splitext(att_fn)[1] == '.doc') or
예제 #42
0
        config = json.load(f)
        username = config['username']
        password = config['password']
        server = config['server']
        repo = config['gh_repo']
        token = config['gh_token']
        if 'ssl' in config:
            ssl = config['ssl']
        if 'delete' in config:
            delete_after = int(config['delete'])
            if delete_after < 0:
                delete_after = 0
    print("Config for " + username + " loaded!")

    with Imbox(server,
               username=username,
               password=password,
               ssl=ssl) as inbox:
        print("Connected...", end="")
        inbox_messages = inbox.messages(unread=True)
        print("mails loaded")
        for uid, message in inbox_messages:
            issueReport = ""
            issueReport += "# " + message.subject + "\r\n"
            issueReport += "Reported by: [" + message.sent_from[0]['name'] + "](mailto:" + message.sent_from[0][
                'email'] + ")\r\n"
            for line in message.body['plain']:
                issueReport += line
            inbox.mark_seen(uid)
            response = requests.post('https://api.github.com/repos/' + repo + '/issues', json={
                'title': message.subject,
                'body': issueReport
예제 #43
0
from imbox import Imbox
'''imap.gmail.com'''
imbox = Imbox('imap.mail.yahoo.com',
              username='******',
              password='******',
              ssl=True)

unread_messages = imbox.messages(unread=True)

for uid, message in unread_messages:
    print("Sent from ", message.sent_from)
    print("Subject ", message.subject)
    print("Body ", message.body.get('plain'))
예제 #44
0
 def login(self, *args, **kwds):
     self.args = args
     self.kwds = kwds
     with Imbox(*args, **kwds):
         self.connected = True
예제 #45
0
    def handle(self):
        if not self.connected:
            raise Exception('Not connected')

        return Imbox(*self.args, **self.kwds)
예제 #46
0
class EmailRecv(EmailBase):
    """
        messages.sent_from	发件人
        messages.sent_to	收件人
        messages.subject	邮件主题
        messages.date	发送日期
        messages.body['plain']	文本格式的正文
        messages.body['html']	HTML格式的正文
        messages.attachments	附件
        messages.parsed_date datetime 类型
    """

    def __init__(self, *args, **kwargs):
        self._server = None
        super(EmailRecv, self).__init__(*args, **kwargs)

    def _login(self, *args, **kwargs):
        if not isinstance(self._server, Imbox):

            self._server = Imbox(self._host, username=self._user,
                                 password=self._pwd, port=self._port, *args, **kwargs)

        return self._server

    def logout(self, *args, **kwargs):
        """
        退出
        :param args:
        :param kwargs:
        :return:
        """
        if isinstance(self._server, Imbox):
            try:
                self._server.logout()
            except Exception as e:
                logging.error('logout error %s', e)

    def folders(self):

        temp_list = list()

        folder_tuple = self._server.folders()
        if folder_tuple[0] != 'OK':
            return
        for folder in folder_tuple[1]:
            readable_folder = mail_decode(folder)
            temp_list.append(readable_folder.split()[-1].strip('"'))
        return temp_list

    def mark_seen(self, uuid):
        """
        标记本邮件已读
        :param uuid: 邮箱唯一编号
        :return:
        """
        self._server.mark_seen(uuid)

    def mark_flag(self, uuid):
        """
        标记红旗邮件
        :param uuid: 邮箱唯一编号
        :return:
        """
        self._server.mark_flag(uuid)

    def delete(self, uuid):
        """
        删除邮件
        :param uuid: 邮箱唯一编号
        :return:
        """
        self._server.delete(uuid)

    def read(self, **kwargs):
        """
        param folder:
              INBOX: (收件箱)
              草稿箱
              已发送
              已删除
              垃圾邮件
              病毒邮件
              广告邮件
        param unread: 未读邮件 bool
        param unflagged: 不是红旗邮件 bool
        param flagged: 红旗邮件 bool
        param sent_from: 读取某个发件人的邮件 str
        param sent_to: 读取某个收件人的邮件 str
        param date__gt: 某天之后
        param date__lt: 某天之前 datetime.date(2019, 10, 28)
        param lookup_error_ignore: 忽略LookUpError 错误 Bool
        param date__on:某天
        param subject: 主提邮件
        :param kwargs:
        :return: iter obj  example (email_id: str, msg:object )
        """
        lookup_error_ignore = kwargs.pop('lookup_error_ignore', False)

        self.__parser_folders(kwargs)
        all_messages = self._server.messages(**kwargs)
        if lookup_error_ignore:
            return self.iter_all_messages(all_messages)
        return all_messages

    @staticmethod
    def iter_all_messages(all_messages):
        n = 0
        length = len(all_messages._uid_list)  # noqa
        while n < length:
            try:
                uid = all_messages._uid_list[n]  # noqa
                msg = all_messages._fetch_email(uid)  # noqa
                n += 1
                yield uid, msg
            except LookupError as e:
                logging.error('uid %s error %s', uid, e)  # noqa
                n += 1

    @staticmethod
    def __parser_folders(folder_other):
        folder = folder_other.pop('folder', None)
        if folder:
            folder_other['folder'] = mail_encode(folder)

    def copy(self, uid, destination_folder):
        """

        :param uid: 邮箱唯一编号
        :param destination_folder: 目标文件夹
        :return:
        """

        return self._server.copy(uid, destination_folder)

    def move(self, uid, destination_folder):
        """
        :param uid: 邮箱唯一编号
        :param destination_folder: 目标文件夹
        :return:
        """
        self._server.move(uid, destination_folder)
예제 #47
0
    def run(self, config, title):
        self._title = title
        SERVER_URL = str(config['mt_server_url'])
        CHANNEL_ID = str(config['mt_channel_id'])

        while True:
            try:
                imbox = Imbox(config["server"],
                              username=config["username"],
                              password=config["password"],
                              ssl=config["ssl"] == 'True',
                              ssl_context=config["ssl_context"],
                              starttls=config["starttls"] == 'True')
            except:
                self.write_error_log("Failed to connect to Mailserver.")
                sys.exit(2)

            try:
                unread_inbox_messages = imbox.messages(unread=True)

                for uid, message in unread_inbox_messages:

                    s = requests.Session()
                    s.headers.update({
                        "Authorization":
                        "Bearer " + str(config['mt_bearer'])
                    })

                    msg = "---\r\n|Field|Value|\r\n|---|---|\r\n"

                    if self.config_boolean(config["mail_subject"]):
                        msg += self.add_message_field("Subject",
                                                      message.subject)

                    if self.config_boolean(config["mail_sent_from"]):
                        msg += self.add_message_field("Sender",
                                                      message.sent_from)

                    if self.config_boolean(config["mail_sent_to"]):
                        msg += self.add_message_field("Recipient",
                                                      message.sent_to)

                    if self.config_boolean(config["mail_date"]):
                        msg += self.add_message_field("Date", message.date)

                    FILE_IDS = list()
                    if self.config_boolean(config["mail_attachments"]):
                        try:
                            att_counter = 0
                            for att in message.attachments:
                                try:
                                    if att_counter < 5:  # max. 5 attachments per post
                                        readable_hash = hashlib.sha256(
                                            att['content'].read()).hexdigest()
                                        FILE_PATH = str(
                                            config['workingdir']) + str(
                                                config['data_folder']) + str(
                                                    att['filename']
                                                )  #str(readable_hash)
                                        att['content'].seek(0)

                                        with open(FILE_PATH, 'wb') as file:
                                            file.write(att['content'].read())

                                        form_data = {
                                            "channel_id": ('', CHANNEL_ID),
                                            "client_ids":
                                            ('', str(readable_hash)),
                                            "files":
                                            (os.path.basename(FILE_PATH),
                                             open(FILE_PATH, 'rb')),
                                        }

                                        r = s.post(SERVER_URL +
                                                   '/api/v4/files',
                                                   files=form_data)
                                        FILE_IDS.append(
                                            str(r.json()["file_infos"][0]
                                                ["id"]))
                                        att_counter += 1

                                        msg += "|Attachment| `" + str(
                                            att['filename']
                                        ) + " [sha256: " + readable_hash + "]`|\r\n"
                                except:
                                    self.write_error_log(
                                        "Failed to save attachment to disk and post to Mattermost."
                                    )
                        except:
                            self.write_error_log("Failed to parse attachment.")

                    if self.config_boolean(config["mail_message_id"]):
                        msg += self.add_message_field("Message-ID",
                                                      message.message_id)

                    if self.config_boolean(config["mail_headers"]):
                        msg += self.add_message_field("Headers",
                                                      message.headers)

                    if self.config_boolean(config["mail_body_plain"]):
                        msg += self.add_message_field("Body",
                                                      message.body["plain"])
                    elif self.config_boolean(config["mail_body_html"]):
                        msg += self.add_message_field("Body",
                                                      message.body["html"])

                    if str(config["mail_tlp"]) != "":
                        msg += self.add_message_field("TLP",
                                                      config["mail_tlp"])

                    data_dict = {
                        "channel_id": CHANNEL_ID,
                        "message": msg,
                        "file_ids": []
                    }
                    data_dict["file_ids"] = FILE_IDS
                    data = json.dumps(data_dict)

                    p = s.post(SERVER_URL + '/api/v4/posts', data)

                    imbox.mark_seen(uid)

            except Exception as e:
                self.write_error_log("Failed to parse email message.")
                exc_type, exc_obj, exc_tb = sys.exc_info()
                fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
                uid = None
                if "uid" in sys.exc_info()[2].tb_next.tb_frame.f_locals:
                    uid = sys.exc_info()[2].tb_next.tb_frame.f_locals["uid"]
                if uid is not None:
                    imbox.mark_seen(uid)

            time.sleep(int(config["sleep"]))
예제 #48
0
def get_emails():
    try:
        given_params = app.current_request.query_params

        # print(given_params)

        folder = given_params["RequestedFolder"]

        email = given_params["email"]
        password = given_params["password"]
        imap_server = given_params["imap_server"]
        imap_port = given_params["imap_port"]

        # print(folder)
        # print(email)
        # print(password)
        # print(imap_server)
        # print(imap_port)

        with Imbox(hostname=imap_server,
                   port=imap_port,
                   username=email,
                   password=password,
                   ssl=True) as imbox:
            all_inbox_messages = imbox.messages(folder=folder)[::-1][0:10]

            if all_inbox_messages:
                # if all_inbox_messages[::-1][0:10]:

                randnum = 0

                emails = []
                # for uid, message in all_inbox_messages[::-1][0:10]:
                for uid, message in all_inbox_messages:

                    # print(uid)

                    randnum = randnum + 1

                    email = {}

                    email["id"] = str(uuid4())

                    # name
                    if message.sent_from[0]["name"]:
                        email["name"] = str(message.sent_from[0]["name"])

                    # email
                    if message.sent_from[0]["email"]:
                        email["email"] = str(message.sent_from[0]["email"])

                    # body (html)
                    if message.body["html"]:
                        email["body_html"] = str(message.body["html"][0])

                    # body (plain)
                    if message.body["plain"]:
                        email["body_plain"] = str(message.body["plain"][0])

                    # subject
                    if message.subject:
                        email["subject"] = str(message.subject)

                    # date
                    if message.date:
                        try:
                            email["date"] = parser.parse(str(
                                message.date)).strftime(
                                    '%Y-%m-%dT%H:%M:%S.%f')[:-3] + "Z"
                        except:
                            email["date"] = datetime.now().strftime(
                                '%Y-%m-%dT%H:%M:%S.%f')[:-3] + "Z"

                    # # bucket
                    # email["bucket"] = "Inbox"

                    # read
                    # email["read"] = False

                    # if message.attachments:
                    #     email["attachments"] = message.attachments

                    emails.append(email)

                print(randnum)

                return Response(body={
                    'emails': emails,
                    "number_of_emails": len(emails)
                },
                                status_code=200,
                                headers=custom_headers)
            else:
                return Response(body={'emails': "No Emails!"},
                                status_code=204,
                                headers=custom_headers)
    except Exception as error:
        # print("Get Emails Error:")
        # print(error)
        return Response(body={'AppError': str(error)},
                        status_code=500,
                        headers=custom_headers)
예제 #49
0
 def __init__(self):
     self.inbox = Imbox("imap.gmail.com", username=userName, password=userPassword, ssl=True)
     self.getMessages()