Example #1
0
def prepareMail(mail):
    newMail = Mail()
    newMail.mop = mail.mop
    newMail.unit = mail.unit
    newMail.type = Mail.TYPE_RECEIVED
    newMail.processed = True
    return newMail
    
Example #2
0
def createMail(bodyType, mop):
    mopco = getUnitComm()
    mail = Mail(bodyType=bodyType, mop=mop, unit=mopco, subject=Mail.SUBJECT_HELP, type=Mail.TYPE_RECEIVED, processed=True)
    #if mail.bodyType == Mail.BODY_TUTORIAL_5_CONCLUSION:
    #    mail.trust = 50
    #    mail.mop.mopTracker.addTrust(mail.trust, True)
    mail.save()
    logging.log_action(ActionLog.ACTION_MOP_RECEIVE_MAIL_TUTORIAL, mop=mop, mail=mail)
Example #3
0
def mail_compose(request):
    #TODO Mail needs a sentAt / savedAt value so that trashing email does not change its date
    if request.method == 'POST':
        mail = Mail(mop=request.user.mop, type=Mail.TYPE_SENT)
        if 'send' in request.POST:
            mail.type = Mail.TYPE_SENT
            mail.read = True
        elif 'draft' in request.POST:
            mail.type = Mail.TYPE_DRAFT
            mail.read = False
        form = MailForm(data=request.POST, instance=mail)
        
        if form.is_valid():
            mail.processed = False
            mail = form.save()
            if mail.type == Mail.TYPE_SENT:
                if not mail.requisitionInstance == None:
                    mail.requisitionInstance.used = True
                    mail.requisitionInstance.save()
                if not mail.mopDocumentInstance == None:
                    mail.mopDocumentInstance.used = True
                    mail.mopDocumentInstance.save()
            
            
            #TODO remove for real game
            analyze_mail()    
            return redirect('mop_index')
        else:
            #TODO code duplication between here and the else below
            form.fields["requisitionInstance"].queryset = RequisitionInstance.objects.filter(blank__mop=request.user.mop).filter(used=False).order_by('-modifiedAt')
            form.fields["mopDocumentInstance"].queryset = MopDocumentInstance.objects.filter(mop=request.user.mop).filter(used=False).order_by('-modifiedAt')
            form.fields["subject"].choices = Mail.CHOICES_SUBJECT_SENDING
            return render(request, 'mop/mail_compose.html', {'form' : form,})
        
    else:
        form =  MailForm()
        form.fields["requisitionInstance"].queryset = RequisitionInstance.objects.filter(blank__mop=request.user.mop).filter(used=False).order_by('-modifiedAt')
        form.fields["mopDocumentInstance"].queryset = MopDocumentInstance.objects.filter(mop=request.user.mop).filter(used=False).order_by('-modifiedAt')
        form.fields["subject"].choices = Mail.CHOICES_SUBJECT_SENDING
        return render(request, 'mop/mail_compose.html', {'form' : form,})
Example #4
0
def remove_old_documents():
    output = []
    randomizedDocument_list = RandomizedDocument.objects.filter(active=True).exclude(mopDocument__clearance=Clearance.CLEARANCE_WHITE)
    for randomizedDocument in randomizedDocument_list:
        if randomizedDocument.dueAt and randomizedDocument.dueAt < now():
            randomizedDocument.active = False
            randomizedDocument.save()
            output.append(randomizedDocument.serial)
            
            mopDocumentInstance_list = MopDocumentInstance.objects.filter(randomizedDocument=randomizedDocument).filter(status=MopDocumentInstance.STATUS_ACTIVE)
            for mopDocumentInstance in mopDocumentInstance_list:
                mopDocumentInstance.status = MopDocumentInstance.STATUS_REVOKED
                mopDocumentInstance.save()
                
                mail = Mail()
                mail.mop = mopDocumentInstance.mop
                mail.type = Mail.TYPE_RECEIVED
                mail.processed = True
                mail.unit = mopDocumentInstance.randomizedDocument.unit
                mail.subject = Mail.SUBJECT_REVOKE_DOCUMENT
                mail.bodyType = Mail.BODY_REVOKING_DOCUMENT
                mail.mopDocumentInstance = mopDocumentInstance
                mail.trust = mopDocumentInstance.getTrustFinal()
                mail.save()
                
                mopDocumentInstance.mop.mopTracker.addTrust(mopDocumentInstance.getTrustFinal(), True)
                mopDocumentInstance.mop.mopTracker.save()
                
    return output
Example #5
0
def analyze_performance(simulation=False):
    output = []

    if simulation:
        output.append("RUNNING SIMULATION")

    # if not simulation:
    #    revokeDocuments()

    mopTracker_list = MopTracker.objects.all().order_by("trust")
    output.append("MoPs under performance review: %d" % mopTracker_list.count())
    lastPeriod, thisPeriod, days = getPeriods()
    today = now().date()

    if not simulation:
        if not thisPeriod.reviewDate == today:
            output.append(
                "No review scheduled for today (%s). Next review scheduled for %s" % (today, thisPeriod.reviewDate)
            )
            return output
        output.append(
            "Last review: %s, This review: %s, Days since last review: %s"
            % (lastPeriod.reviewDate, thisPeriod.reviewDate, days)
        )
        if days == 0:
            output.append("No performance review possible.")
            return output
    else:
        output.append(
            "Last review: %s, This review: %s, Days since last review: %s"
            % (lastPeriod.reviewDate, thisPeriod.reviewDate, days)
        )

    for mopTracker in mopTracker_list:
        performanceInstance, out = doPerformance(mopTracker.mop, thisPeriod, days)
        output.append(out)
        if simulation:
            continue
        performanceInstance.save()

        mopTracker.clearance = performanceInstance.result
        mopTracker.totalTrust += mopTracker.trust
        mopTracker.trust = 0
        mopTracker.credit = performanceInstance.credit
        mopTracker.save()

        unit = Unit.objects.filter(type=Unit.TYPE_ADMINISTRATIVE)[0]

        mail = Mail(
            mop=mopTracker.mop,
            performanceInstance=performanceInstance,
            unit=unit,
            subject=Mail.SUBJECT_INFORMATION,
            type=Mail.TYPE_RECEIVED,
        )
        if performanceInstance.type == PerformanceInstance.TYPE_PROMOTION:
            mail.bodyType = Mail.BODY_PERFORMANCE_REPORT_PROMOTION
        elif performanceInstance.type == PerformanceInstance.TYPE_DEMOTION:
            mail.bodyType = Mail.BODY_PERFORMANCE_REPORT_DEMOTION
        else:
            mail.bodyType = Mail.BODY_PERFORMANCE_REPORT_NEUTRAL
        mail.save()
        logging.log_action(ActionLog.ACTION_MOP_RECEIVE_MAIL_PERFORMANCE, mop=mopTracker.mop, mail=mail)
    if not simulation:
        thisPeriod.processed = True
        thisPeriod.reviewTime = now().time()
        thisPeriod.save()
        if not PerformancePeriod.objects.filter(processed=False):
            newPeriod = PerformancePeriod()
            newDate = thisPeriod.reviewDate + datetime.timedelta(days=14)
            newPeriod.reviewDate = newDate
            newPeriod.save()
    return output