rowsandall/rowers/mailprocessing.py

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

# Processes emails sent to workouts@rowsandall.com
""" Processes emails sent to workouts@rowsandall.com """
import shutil
import time
from django.conf import settings
from rowers.tasks import (
    handle_sendemail_unrecognized,
    handle_sendemail_unrecognizedowner
    )
from django_mailbox.models import Message, MessageAttachment,Mailbox

#workoutmailbox = Mailbox.objects.get(name='workouts')
#failedmailbox = Mailbox.objects.get(name='Failed')


from rowers.models import User, Rower, RowerForm

from django.core.mail import EmailMessage

from rowingdata import rower as rrower

from rowingdata import rowingdata as rrdata

from rowingdata import get_file_type

import zipfile
import os
import rowers.dataprep as dataprep

import django_rq
queue = django_rq.get_queue('default')
queuelow = django_rq.get_queue('low')
queuehigh = django_rq.get_queue('default')

# Sends a confirmation with a link to the workout
from rowers.emails import send_template_email

def send_confirm(user, name, link, options): # pragma: no cover
    d = {
        'first_name':user.first_name,
        'name':name,
        'link':link,
        }

    fullemail = user.email
    subject = 'New Workout Added: '+name

    res = send_template_email('Rowsandall <info@rowsandall.com>',
                              [fullemail],
                              subject,'confirmemail.html',
                              d
                              )

    return 1

# Reads a "rowingdata" object, plus some error protections


def rdata(file, rower=rrower()):
    """ Reads rowingdata data or returns 0 on Error """
    try:
        result = rrdata(csvfile=file, rower=rower)
    except IOError: # pragma: no cover
        try:
            result = rrdata(csvfile=file + '.gz', rower=rower)
        except IOError:
            result = 0
    except TypeError: # pragma: no cover
        try:
            result = rrdata(csvfile=file)
        except IOError:
            try:
                result = rrdata(csvfile=file+'.gz', rower=rower)
            except IOError:
                result = 0

    return result



def make_new_workout_from_email(rower, datafile, name, cntr=0,testing=False):
    """ This one is used in processemail """
    workouttype = 'rower'
    impeller = False

    try: # pragma: no cover
        datafilename = datafile.name
        fileformat = get_file_type('media/' + datafilename)
        raise ValueError
    except IOError: # pragma: no cover
        datafilename = datafile.name + '.gz'
        fileformat = get_file_type('media/' + datafilename)
    except AttributeError:
        datafilename = datafile
        fileformat = get_file_type('media/' + datafile)

    if len(fileformat) == 3 and fileformat[0] == 'zip': # pragma: no cover
        with zipfile.ZipFile('media/' + datafilename) as zip_file:
            datafilename = zip_file.extract(
                zip_file.namelist()[0],
                path='media/')[6:]
            fileformat = fileformat[2]




    f,e = os.path.splitext(datafilename)
    if fileformat == 'unknown' and 'txt' not in e:
        fcopy = "media/"+datafilename
        if not testing: # pragma: no cover
            if settings.CELERY:
                res = handle_sendemail_unrecognized.delay(
                    fcopy,
                    rower.user.email
                )
                res = handle_sendemail_unrecognizedowner.delay(
                    rower.user.email,
                    rower.user.first_name
                )
            else:
                res = queuehigh.enqueue(handle_sendemail_unrecognized,
                                        fcopy,
                                        rower.user.email)
                res = queuehigh.enqueue(handle_sendemail_unrecognizedowner,
                                        rower.user.email,
                                        rower.user.first_name
                )
        return 0

    summary = ''


    # handle non-Painsled
    if fileformat == 'att':
        return 0
    if fileformat != 'csv':
        filename_mediadir, summary, oarlength, inboard,fileformat,impeller = dataprep.handle_nonpainsled(
            'media/' + datafilename, fileformat, summary)
        if not filename_mediadir: # pragma: no cover
            return 0
    else:
        filename_mediadir = 'media/' + datafilename
        inboard = 0.88
        oarlength = 2.89

    row = rdata(filename_mediadir)
    if row == 0: # pragma: no cover
        return 0

    # change filename
    if datafilename[:5] != 'media':
        timestr = time.strftime("%Y%m%d-%H%M%S")
        datafilename = 'media/' + timestr + str(cntr) + 'o.csv'

    try:
        avglat = row.df[' latitude'].mean()
        avglon = row.df[' longitude'].mean()
        if avglat != 0 or avglon != 0:
            workouttype = 'water'
    except KeyError:
        pass

    row.write_csv(datafilename, gzip=True)
    dosummary = (fileformat != 'fit' and 'speedcoach2' not in fileformat)
    dosummary = dosummary or summary == ''

    if name == '': # pragma: no cover
        name = 'Workout from Background Queue'

    id, message = dataprep.save_workout_database(
        datafilename, rower,
        workouttype=workouttype,
        dosummary=dosummary,
        summary=summary,
        inboard=inboard,
        oarlength=oarlength,
        title=name,
        dosmooth=rower.dosmooth,
        workoutsource=fileformat,
        notes='',impeller=impeller,
    )


    return id