def activate_study(request, code):
try:
cron = Cron.objects.get(activationCode=code)
except Cron.DoesNotExist:
cron = None
if cron == None:
return render(request, 'players/registration.html', {"wrongCode": True})
elif cron.activated:
return render(request, 'players/registration.html', {"alreadyActivated": True})
else:
if request.method == 'POST':
form = PlayerForm(request.POST, prefix="player")
if form.is_valid():
player = form.save()
cron.player = player
cron.activated = True
cron.save()
logging.log_action(ActionLog.ACTION_CRON_ACTIVATED, cron)
return render(request, 'players/registration.html', {"cron": player.cron, "study":True})
else:
return render(request, 'players/study.html', {"form": form, "code":code})
else:
form = PlayerForm(prefix='player')
logging.log_action(ActionLog.ACTION_CRON_VIEW_STUDY, cron)
return render(request, 'players/study.html', {"form": form, "code":code})
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)
def promotion_email(mop, bodyType):
mail = Mail()
mail.unit = Unit.objects.filter(type=Unit.TYPE_ADMINISTRATIVE)[0]
mail.subject = Mail.SUBJECT_INFORMATION
mail.bodyType = bodyType
mail.type = Mail.TYPE_RECEIVED
mail.processed = True
mail.mop = mop
mail.save()
from logger.models import ActionLog
from logger import logging
data = json.dumps({'totalTrust':mop.mopTracker.totalTrust, 'newClearance':mop.mopTracker.clearance})
logging.log_action(ActionLog.ACTION_MOP_RECEIVE_MAIL_PERFORMANCE, mop=mop, mail=mail, data=data)
def checkProvenance(mopTracker, correct):
if mopTracker.tutorial == MopTracker.TUTORIAL_3_SENT_HOW_TO_CHECK_PROVENANCE:
if correct:
createMail(Mail.BODY_TUTORIAL_4c_CORRECT_MODIFICATION, mopTracker.mop)
mopTracker.tutorial = MopTracker.TUTORIAL_4_SENT_HOW_TO_SUBMIT_DOCUMENT
mopTracker.save()
logging.log_action(ActionLog.ACTION_MOP_TUTORIAL_PROGRESS, mop=mopTracker.mop, tutorialProgress=mopTracker.tutorial)
else:
mopTracker.tutorialProvErrors += 1
mopTracker.save()
if mopTracker.tutorialProvErrors > 1:
createMail(Mail.BODY_TUTORIAL_4b_INCORRECT_MODIFICATION_2, mopTracker.mop)
else:
createMail(Mail.BODY_TUTORIAL_4a_INCORRECT_MODIFICATION, mopTracker.mop)
def activate_nostudy(request, code):
try:
cron = Cron.objects.get(activationCode=code)
except Cron.DoesNotExist:
cron = None
if cron == None:
return render(request, 'players/registration.html', {"wrongCode": True})
elif cron.activated:
return render(request, 'players/registration.html', {"alreadyActivated": True})
else:
cron.activated = True
cron.save()
logging.log_action(ActionLog.ACTION_CRON_CREATED, cron)
return render(request, 'players/registration.html', {"cron": cron})
def register(request):
if request.method == 'POST':
cron_form = CronForm(request.POST, prefix="cron")
user_form = UserCreationForm(request.POST, prefix = "user")
if cron_form.is_valid() and user_form.is_valid():
user = user_form.save()
cron = cron_form.save(commit=False)
cron.user = user
cron.save()
logging.log_action(ActionLog.ACTION_CRON_CREATED, cron)
email_tpl = loader.get_template('players/activation.txt')
url_study = request.build_absolute_uri(reverse('players_activation_study', args=[cron.activationCode]))
url_nostudy = request.build_absolute_uri(reverse('players_activation_nostudy', args=[cron.activationCode]))
c = Context({
'cron': cron, 'url_study':url_study, 'url_nostudy':url_nostudy
})
email = EmailMessage(
subject='[cr0n] Activate your account',
body= email_tpl.render(c),
to=[cron.email,],
)
#in settings.py you can configure console backend for displaying emails instead of sending them - great for testing!
email.send(fail_silently=False)
return render(request, 'players/registration.html', {"registered": True, "cron":cron})
else:
return render(request, 'players/registration.html', {"cron_form": cron_form, "user_form": user_form})
else:
cron_form = CronForm(prefix='cron')
user_form = UserCreationForm(prefix='user')
return render(request, 'players/registration.html', {"cron_form": cron_form, "user_form": user_form})
def assignDocument(mopTracker):
if mopTracker.tutorial == MopTracker.TUTORIAL_2_SENT_HOW_TO_REQUEST_DOCUMENT:
createMail(Mail.BODY_TUTORIAL_3_TASK_COMPLETION, mopTracker.mop)
mopTracker.tutorial = MopTracker.TUTORIAL_3_SENT_HOW_TO_CHECK_PROVENANCE
mopTracker.save()
logging.log_action(ActionLog.ACTION_MOP_TUTORIAL_PROGRESS, mop=mopTracker.mop, tutorialProgress=mopTracker.tutorial)
def assignForm(mopTracker):
if mopTracker.tutorial == MopTracker.TUTORIAL_1_SENT_HOW_TO_REQUEST_FORM:
createMail(Mail.BODY_TUTORIAL_2_DOCUMENT_REQUEST, mopTracker.mop)
mopTracker.tutorial = MopTracker.TUTORIAL_2_SENT_HOW_TO_REQUEST_DOCUMENT
mopTracker.save()
logging.log_action(ActionLog.ACTION_MOP_TUTORIAL_PROGRESS, mop=mopTracker.mop, tutorialProgress=mopTracker.tutorial)
def firstLogin(mopTracker):
createMail(Mail.BODY_TUTORIAL_1_INTRO, mopTracker.mop)
mopTracker.tutorial = MopTracker.TUTORIAL_1_SENT_HOW_TO_REQUEST_FORM
mopTracker.save()
logging.log_action(ActionLog.ACTION_MOP_TUTORIAL_PROGRESS, mop=mopTracker.mop, tutorialProgress=mopTracker.tutorial)
def cronMail(mopTracker, mail):
if mopTracker.tutorial == MopTracker.TUTORIAL_5_SENT_CONCLUSION and mail.bodyType == Mail.BODY_TUTORIAL_5_CONCLUSION:
mopTracker.tutorial = MopTracker.TUTORIAL_6_DONE
mopTracker.save()
logging.log_action(ActionLog.ACTION_MOP_TUTORIAL_PROGRESS, mop=mopTracker.mop, tutorialProgress=mopTracker.tutorial)
mailer.mopTutorialDone(mopTracker.mop.cron)
def submitDocument(mopTracker):
if mopTracker.tutorial == MopTracker.TUTORIAL_4_SENT_HOW_TO_SUBMIT_DOCUMENT:
createMail(Mail.BODY_TUTORIAL_5_CONCLUSION, mopTracker.mop)
mopTracker.tutorial = MopTracker.TUTORIAL_5_SENT_CONCLUSION
mopTracker.save()
logging.log_action(ActionLog.ACTION_MOP_TUTORIAL_PROGRESS, mop=mopTracker.mop, tutorialProgress=mopTracker.tutorial)
def prov_check(request):
correct = False
message = "This is not correct."
status = "ok"
if not request.user.is_active:
json_data = json.dumps({"message":"You are currently not logged in. Please login to continue.", "status":"logged_out"})
return HttpResponse(json_data, mimetype="application/json")
#if request.is_ajax():
if request.method == 'POST':
serial = request.POST.get('serial', "")
post_node1 = request.POST.get('node1', "")
post_node2 = request.POST.get('node2', "")
post_attribute1 = request.POST.get('attribute1', "")
post_attribute2 = request.POST.get('attribute2', "")
is_empty = json.loads(request.POST.get('is_empty', False))
is_test = json.loads(request.POST.get('is_test', False))
player_attribute1 = makeAttributeString(post_node1, post_attribute1)
player_attribute2 = makeAttributeString(post_node2, post_attribute2)
try:
provenance = Provenance.objects.get(serial=serial)
try:
attribute1_json = json.loads(provenance.attribute1)
attribute2_json = json.loads(provenance.attribute2)
except:
attribute1_json = []
attribute2_json = []
#if we have no proper serial in the post, then we are probably looking at a randomized MOP_TEMPLATE
except Provenance.DoesNotExist:
provenance = Provenance.objects.get(id=request.session['prov_id'])
try:
attribute1_json = json.loads(request.session['attribute1'])
attribute2_json = json.loads(request.session['attribute2'])
except:
attribute1_json = None
attribute2_json = None
print 'got stuff from the session cookie'
stored_attribute1_list = []
stored_attribute2_list = []
if provenance.attribute1 is None and provenance.attribute2 is None:
if is_empty:
correct = True
else:
for a_json in attribute1_json:
stored_attribute1_list.append(makeAttributeString(a_json['node'], a_json['attribute']))
for a_json in attribute2_json:
stored_attribute2_list.append(makeAttributeString(a_json['node'], a_json['attribute']))
if player_attribute1 in stored_attribute1_list and player_attribute2 in stored_attribute2_list:
correct = True
elif player_attribute1 in stored_attribute2_list and player_attribute2 in stored_attribute1_list:
correct = True
stars = None
if is_test and request.user.is_staff:
if correct:
message = "Test feedback: Yes, this is where the inconsistency is!"
else:
message = "Test feedback: No, this is not correct."
close_prov = False
else:
cronDocumentInstance = None
mopDocumentInstance = None
if provenance.type == Provenance.TYPE_CRON:
#TODO check properly for cron-user and if Instance exists
cronDocumentInstance = CronDocumentInstance.objects.get(cronDocument=provenance.document, cron=request.user.cron)
logging.log_action(ActionLog.ACTION_CRON_PROVENANCE_SUBMIT, cron=cronDocumentInstance.cron, cronDocumentInstance=cronDocumentInstance, cronDocumentInstanceCorrect=correct)
if correct:
cronDocumentInstance.solved = True
cronDocumentInstance.save()
close_prov = True
stars = cronDocumentInstance.getStars()
attempts = cronDocumentInstance.failedAttempts + 1
if stars == 3:
message = "Excellent job! This will be reflected in your agent profile."
elif stars == 2:
message = "It took you %s tries, but good job anyway. Your agent profile has been updated." % attempts
elif stars == 1:
message = "Yes, you did it. It did take %s attempts, but the result is what counts. Your success has been logged in your agent profile." % attempts
else:
cronDocumentInstance.increaseFailedAttempts()
close_prov = False
if cronDocumentInstance.failedAttempts >= 50:
message = "Yeah. Not it."
elif cronDocumentInstance.failedAttempts >= 30:
message = "Honestly, now you are just guessing, right? Contact HQ, they might have uncovered an additional clue!"
elif cronDocumentInstance.failedAttempts >= 10:
message = "You are trying very hard, but this is not it. Maybe send a message to HQ to see if they have more intel."
elif is_empty:
message = "No, we are pretty sure that something is wrong with this data. Please keep investigating."
else:
message = "The data you submitted does not seem suspicious. Please keep investigating."
elif provenance.type == Provenance.TYPE_MOP_INSTANCE:
message = "Provenance modification saved. Please submit document now."
#TODO check properly for mop-user and if Instance exists
mopDocumentInstance = MopDocumentInstance.objects.get(randomizedDocument=provenance.randomizedDocument, mop=request.user.mop)
mopDocumentInstance.modified = True
mopDocumentInstance.correct = correct
mopDocumentInstance.save()
logging.log_action(ActionLog.ACTION_MOP_PROVENANCE_SUBMIT, mop=mopDocumentInstance.mop, mopDocumentInstance=mopDocumentInstance, mopDocumentInstanceCorrect=correct)
tutorial.checkProvenance(mopDocumentInstance.mop.mopTracker, mopDocumentInstance.correct)
close_prov = True
logging.log_prov(action=ProvLog.ACTION_SUBMIT, cronDocumentInstance=cronDocumentInstance, mopDocumentInstance=mopDocumentInstance, node1=post_node1, node2=post_node2, attribute1=post_attribute1, attribute2=post_attribute2, empty=is_empty, correct=correct)
json_data = json.dumps({"close_prov":close_prov, "status":status, "message":message, "stars":stars})
return HttpResponse(json_data, mimetype="application/json")
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
